Upload 765 files

.gitattributes

@@ -34,3 +34,18 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 ML_AGENT[[:space:]]Unity[[:space:]]Usage.docx filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Assets/Model/dt_model_12.onnx.data filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Assets/Model/dt_model_final.onnx.data filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Assets/Model/dt_model.onnx.data filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Assets/Model/Old/dt_model_11.onnx[[:space:]]1.data filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Assets/Model/Old/dt_model_11.onnx.data filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Packages/Newtonsoft.Json.13.0.4/lib/net20/Newtonsoft.Json.dll filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Packages/Newtonsoft.Json.13.0.4/lib/net35/Newtonsoft.Json.dll filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Packages/Newtonsoft.Json.13.0.4/lib/net40/Newtonsoft.Json.dll filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Packages/Newtonsoft.Json.13.0.4/lib/net45/Newtonsoft.Json.dll filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Packages/Newtonsoft.Json.13.0.4/lib/net6.0/Newtonsoft.Json.dll filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Packages/Newtonsoft.Json.13.0.4/lib/netstandard1.0/Newtonsoft.Json.dll filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Packages/Newtonsoft.Json.13.0.4/lib/netstandard1.3/Newtonsoft.Json.dll filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Packages/Newtonsoft.Json.13.0.4/lib/netstandard2.0/Newtonsoft.Json.dll filter=lfs diff=lfs merge=lfs -text
+Upload/01_Source_Code/Unity_Evaluation/Packages/Newtonsoft.Json.13.0.4/Newtonsoft.Json.13.0.4.nupkg filter=lfs diff=lfs merge=lfs -text
+Upload/06_Evaluation_Results/Manuscript_Figures/figure-17.png filter=lfs diff=lfs merge=lfs -text

Upload/01_Source_Code/Python_Evaluation/RevisionAdditional_20260911/Tools/Run-Unity.ps1

@@ -0,0 +1,32 @@
+param(
+    [ValidateSet('Verify','Run','Latency')][string]$Mode = 'Verify',
+    [string]$JobPath = '',
+    [string]$RunName = 'additional-verification'
+)
+$ErrorActionPreference = 'Stop'
+$taskRoot = Split-Path -Parent $PSScriptRoot
+$root = Split-Path -Parent (Split-Path -Parent $taskRoot)
+$projectRoot = Join-Path $root 'RevisionEval'
+$editor = 'C:/Program Files/Unity/Hub/Editor/6000.0.62f1/Editor/Unity.exe'
+$method = if ($Mode -eq 'Run') { 'RevisionEvaluationBatch.Run' } elseif ($Mode -eq 'Verify') { 'AdditionalEvaluationTools.Verify' } else { 'AdditionalEvaluationTools.MeasureLatency' }
+if (Test-Path -LiteralPath "$taskRoot/Logs/$RunName.log") { throw 'Use a fresh run name; prior logs are preserved.' }
+$editorArguments = @('-batchmode','-force-d3d11','-projectPath',('"'+$projectRoot+'"'),
+    '-executeMethod',$method,'-logFile',('"'+$taskRoot+'/Logs/'+$RunName+'.log"'))
+if ($Mode -eq 'Run') {
+    $job = Get-Content -LiteralPath $JobPath -Raw -Encoding UTF8 | ConvertFrom-Json
+    $editorArguments += @('-evaluationJob',('"'+(Resolve-Path -LiteralPath $JobPath).Path+'"'),
+        '-evaluationOutput',('"'+$job.output+'"'))
+} else {
+    $editorArguments += @('-evaluationFixtures',('"'+$taskRoot+'/Verification/actual-input-parity.json"'),
+        '-originalFixtures',('"'+$root+'/Document/RevisionEvaluation_Local_20260910/Verification/E_1_DT_C_5_sequence_fixtures.json"'),
+        '-evaluationReport',('"'+$taskRoot+'/Reports/'+$RunName+'.json"'))
+}
+$editorArguments | ConvertTo-Json | Set-Content -LiteralPath "$taskRoot/Reports/$RunName-command.json" -Encoding UTF8
+$taskProcess = Start-Process -FilePath $editor -ArgumentList $editorArguments -WindowStyle Hidden -PassThru
+$taskProcess.Id | Set-Content -LiteralPath "$taskRoot/Reports/$RunName.pid"
+Write-Output "$RunName Unity PID: $($taskProcess.Id)"
+$taskProcess.WaitForExit()
+$taskProcess.Refresh()
+$taskProcess.ExitCode | Set-Content -LiteralPath "$taskRoot/Reports/$RunName-exit-code.txt"
+Write-Output "$RunName exit code: $($taskProcess.ExitCode)"
+exit $taskProcess.ExitCode

Upload/01_Source_Code/Python_Evaluation/RevisionAdditional_20260911/Tools/analyze_diagnostics.py

@@ -0,0 +1,63 @@
+"""Reproducible follow-up contrasts; analysis is exploratory after observing results."""
+import hashlib
+import json
+from pathlib import Path
+from analyze_statistics import METRICS, holm, paired
+
+TASK = Path(__file__).resolve().parents[1]
+
+
+def load(p):
+    return json.loads(p.read_text(encoding='utf-8-sig'))
+
+
+def one(folder):
+    files = sorted(folder.rglob('*.json'))
+    assert len(files) == 1
+    return files[0], load(files[0])
+
+
+def provenance(files):
+    return [dict(path=str(p.relative_to(TASK)), sha256=hashlib.sha256(p.read_bytes()).hexdigest()) for p in files]
+
+
+def save(name, report):
+    (TASK / 'Reports' / name).write_text(json.dumps(report, indent=2), encoding='utf-8')
+
+
+def main():
+    pa, a = one(TASK / 'Results/bc-diagnostic/bc-normal')
+    pb, b = one(TASK / 'Results/bc-diagnostic/bc-legacy-rtg')
+    assert not a['evaluation']['diagnostic_only'] and b['evaluation']['diagnostic_only']
+    bc = [paired(a, b, metric, 'BC diagnostic/' + metric) for metric in METRICS]
+    for r, p in zip(bc, holm([r['p_raw'] for r in bc])):
+        r['p_holm_6'] = p
+    save('bc-diagnostic-effect.json', dict(status='passed',
+         scope='Diagnostic only; same fixed BC weights and paired initial states. Normal minus legacy-decrement.',
+         selection='Exploratory follow-up analysis after observing diagnostic results.',
+         holm_family_size=6, files=provenance([pa, pb]), comparisons=bc))
+    records = [(p, load(p)) for p in sorted((TASK / 'Results/rtg').rglob('*.json'))]
+    assert len(records) == 13
+    refs = [d for p, d in records if d['evaluation']['policy_type'] == 'DT' and d['evaluation']['initial_rtg'] == 70]
+    assert len(refs) == 1
+    reference = refs[0]
+    rows = []
+    for p, d in records:
+        m = d['evaluation']
+        if d is reference:
+            continue
+        for metric in METRICS:
+            r = paired(d, reference, metric, f"RTG contrast/{m['policy_type']}/{m['initial_rtg']}/{metric}")
+            r.update(policy=m['policy_type'], initial_rtg=m['initial_rtg'], reference='DT initial RTG 70')
+            rows.append(r)
+    assert len(rows) == 72
+    for r, p in zip(rows, holm([r['p_raw'] for r in rows])):
+        r['p_holm_72'] = p
+    save('rtg-statistics.json', dict(status='passed',
+         selection='Exploratory analysis after observing the RTG sweep; reference 70 is the unchanged main-evaluation setting.',
+         holm_family_size=72, files=provenance([p for p, d in records]), comparisons=rows))
+    print(json.dumps(dict(status='passed', bc_comparisons=len(bc), rtg_comparisons=len(rows))))
+
+
+if __name__ == '__main__':
+    main()

Upload/01_Source_Code/Python_Evaluation/RevisionAdditional_20260911/Tools/analyze_reward_components.py

@@ -0,0 +1,44 @@
+"""Algebraic reward decomposition from recorded hits, wins and total rewards."""
+import hashlib
+import json
+from pathlib import Path
+import numpy as np
+
+TASK = Path(__file__).resolve().parents[1]
+ROOT = TASK.parents[1]
+
+
+def main():
+    files = sorted((TASK / 'Results/heldout').rglob('*.json'))
+    assert len(files) == 9
+    rows = []
+    for p in files:
+        d = json.loads(p.read_text(encoding='utf-8-sig'))
+        m = d['evaluation']
+        assert m['reward_protocol'] == 'ShootingAgent-shaped-angle-v1'
+        hits = np.asarray(m['episode_shots_hit'], dtype=float)
+        wins = np.asarray(d['all_wins'], dtype=bool)
+        rewards = np.asarray(d['all_rewards'], dtype=float)
+        remaining = m['target_count'] - hits
+        assert len(hits) == len(wins) == len(rewards) == 200
+        assert np.all(remaining >= 0) and np.array_equal(wins, remaining == 0)
+        hit_reward = 3 * hits
+        terminal = np.where(wins, 2., -.01 * remaining)
+        residual = rewards - hit_reward - terminal
+        rows.append(dict(model=m['model_name'], targets=m['target_count'], episodes=200,
+                         mean_total_reward=float(rewards.mean()), mean_hit_reward=float(hit_reward.mean()),
+                         mean_terminal_reward=float(terminal.mean()), mean_step_shaping_residual=float(residual.mean()),
+                         mean_action_steps=float(np.mean(d['all_steps'])),
+                         file=str(p.relative_to(TASK)), sha256=hashlib.sha256(p.read_bytes()).hexdigest()))
+    source = ROOT / 'RevisionEval/Assets/Script/Trajectory/EvaluationReward.cs'
+    report = dict(status='passed',
+                  method='Residual = recorded total - 3*hits - terminal (2 for success, -0.01*remaining at timeout).',
+                  limitation='Residual combines alignment, fire/no-fire shaping and step penalties, plus float accumulation error. These terms were not separately logged.',
+                  reward_source=str(source.relative_to(ROOT)), source_sha256=hashlib.sha256(source.read_bytes()).hexdigest(),
+                  rows=rows)
+    (TASK / 'Reports/heldout-reward-components.json').write_text(json.dumps(report, indent=2), encoding='utf-8')
+    print(json.dumps(dict(status='passed', rows=len(rows))))
+
+
+if __name__ == '__main__':
+    main()

Upload/01_Source_Code/Python_Evaluation/RevisionAdditional_20260911/Tools/analyze_statistics.py

@@ -0,0 +1,116 @@
+"""Paired, fixed-checkpoint evaluation analysis. Never modifies raw results."""
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import numpy as np
+import scipy
+from scipy import stats
+
+TASK = Path(__file__).resolve().parents[1]
+METRICS = ['all_wins', 'all_steps', 'all_rewards', 'all_smoothness', 'all_accuracies', 'all_actual_firing_accuracies']
+
+def seed_for(label):
+    return int(hashlib.sha256(label.encode()).hexdigest()[:8], 16)
+
+def mean_ci(x, label):
+    x = np.asarray(x, dtype=float)
+    if np.ptp(x) == 0:
+        return [float(x[0]), float(x[0])]
+    res = stats.bootstrap((x,), np.mean, confidence_level=.95, n_resamples=19999,
+                          batch=512, method='percentile', random_state=seed_for(label))
+    return [float(res.confidence_interval.low), float(res.confidence_interval.high)]
+
+def holm(ps):
+    order = np.argsort(ps)
+    out = np.empty(len(ps))
+    out[order] = np.minimum(1., np.maximum.accumulate(np.asarray(ps)[order] * np.arange(len(ps), 0, -1)))
+    return out.tolist()
+
+def paired(a, b, metric, label):
+    for key in ['episode_seeds', 'initial_state_sha256', 'initial_states']:
+        assert a['evaluation'][key] == b['evaluation'][key], f'Pair mismatch: {key}'
+    x, y = np.asarray(a[metric], dtype=float), np.asarray(b[metric], dtype=float)
+    d = x-y
+    row = dict(metric=metric, n=len(d), mean_a=float(x.mean()), mean_b=float(y.mean()), difference_a_minus_b=float(d.mean()))
+    if metric == 'all_wins':
+        ab = int(np.sum((x == 1) & (y == 0)))
+        ba = int(np.sum((x == 0) & (y == 1)))
+        row.update(test='exact McNemar via two-sided binomial discordance test', a_only_success=ab,
+                   b_only_success=ba, p_raw=float(stats.binomtest(ab, ab+ba, .5).pvalue) if ab+ba else 1.,
+                   difference_ci95=None, ci_note='Report exact marginal success CIs; no degenerate binary bootstrap CI.')
+    else:
+        p = 1. if np.all(d == 0) else stats.permutation_test((d,), np.mean,
+                    permutation_type='samples', alternative='two-sided', n_resamples=49999,
+                    batch=512, random_state=seed_for(label)).pvalue
+        row.update(test='paired sign permutation of mean difference', p_raw=float(p),
+                   difference_ci95=mean_ci(d, label+' CI'))
+    return row
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('root', type=Path)
+    p.add_argument('name')
+    args = p.parse_args()
+    assert holm([.01, .04, .03]) == [.03, .06, .06]
+    assert stats.binomtest(3, 3, .5).pvalue == .25
+    records, descriptive, files = {}, [], []
+    for file in sorted(args.root.rglob('*.json')):
+        d = json.loads(file.read_text(encoding='utf-8-sig'))
+        if 'all_wins' not in d: continue
+        m = d['evaluation']
+        assert not m.get('diagnostic_only', False)
+        identity = (m['target_count'], m['model_name'])
+        assert identity not in records
+        records[identity] = d
+        files.append(dict(path=str(file), sha256=hashlib.sha256(file.read_bytes()).hexdigest()))
+        n = len(d['all_wins']); k = sum(d['all_wins'])
+        ci = stats.binomtest(k,n).proportion_ci(method='exact')
+        row = dict(targets=m['target_count'], model=m['model_name'], episodes=n, successes=k,
+                   success_percent=100*k/n, success_ci95_percent=[100*ci.low,100*ci.high], metrics={})
+        for metric in METRICS[1:]:
+            x=np.asarray(d[metric],dtype=float)
+            row['metrics'][metric]=dict(mean=float(x.mean()), sample_sd=float(x.std(ddof=1)),
+                                      mean_ci95=mean_ci(x,str(identity)+metric))
+        descriptive.append(row)
+    comparisons=[]
+    for target in sorted({k[0] for k in records}):
+        models={name:d for (t,name),d in records.items() if t==target}
+        ppos=[name for name,d in models.items() if d['evaluation']['policy_type']=='PPO']
+        assert len(ppos)==1
+        contrasts=[(name,ppos[0]) for name in models if name.startswith('E_3_')]
+        contrasts.append(('E_3_DT_S_100','E_3_DT_BC_100'))
+        for a,b in contrasts:
+            for metric in METRICS:
+                row=paired(models[a],models[b],metric,f'{args.name}/{target}/{a}/{b}/{metric}')
+                row.update(targets=target, model_a=a, model_b=b)
+                comparisons.append(row)
+    for row,adjusted in zip(comparisons,holm([r['p_raw'] for r in comparisons])):
+        row['p_holm']=adjusted
+        row['significant_holm_005']=adjusted<.05
+    report=dict(status='passed', analysis_name=args.name, numpy=np.__version__, scipy=scipy.__version__,
+        inference_scope='Fixed checkpoints over paired environmental episodes; no independent training-run inference.',
+        selection='Follow-up analysis selected after inspecting the previous full results.',
+        assumptions='Independent environment episodes; paired label exchangeability for permutation null. PPO action RNG remains stochastic.',
+        confidence_intervals='Marginal 95%, not multiplicity-adjusted. Degenerate continuous bootstrap CIs report observed lack of variability only.',
+        holm_family_size=len(comparisons), files=files, descriptive=descriptive, comparisons=comparisons)
+    (TASK/'Reports'/f'{args.name}-statistics.json').write_text(json.dumps(report,indent=2),encoding='utf-8')
+    lines=['# 짝지은 평가 통계 분석', '', '고정된 모델 가중치의 환경 에피소드 비교다. E1/E2/E3를 독립 학습 반복으로 합산하지 않았다.',
+           f'전체 {len(comparisons)}개 비교에 Holm 보정. CI는 개별 95% 구간이며 동시 신뢰구간이 아니다.', '',
+           '| 표적 | 모델 | 성공/평가 | 성공률 정확 95% CI | 평균 종료 step | 평균 보상 |', '|---:|---|---:|---|---:|---:|']
+    for r in descriptive:
+        if not r['model'].startswith('E_3') and r['model']!='V12 PPO':continue
+        lo,hi=r['success_ci95_percent']
+        lines.append(f"| {r['targets']} | {r['model']} | {r['successes']}/{r['episodes']} | {lo:.2f}–{hi:.2f}% | {r['metrics']['all_steps']['mean']:.2f} | {r['metrics']['all_rewards']['mean']:.4f} |")
+    lines+=['','## DT_S100과 BC100 비교','','차이는 DT−BC. 성공률은 비율 단위, 정확도는 percentage points.','',
+            '| 표적 | 지표 | 평균 차이 | 차이 95% CI | 보정 전 p | Holm p |','|---:|---|---:|---|---:|---:|']
+    for r in comparisons:
+        if r['model_b']!='E_3_DT_BC_100':continue
+        ci=r.get('difference_ci95')
+        ci_text='별도 추정하지 않음' if ci is None else f'{ci[0]:.5f}–{ci[1]:.5f}'
+        lines.append(f"| {r['targets']} | {r['metric']} | {r['difference_a_minus_b']:.5f} | {ci_text} | {r['p_raw']:.6g} | {r['p_holm']:.6g} |")
+    lines+=['','비유의 결과는 동등성 증명이 아니다. 평균 종료 step은 timeout도 포함한다. 모든 비교와 입력 파일 해시는 JSON에 기록했다.']
+    (TASK/f'{args.name}_STATISTICS_KO.md').write_text('\n'.join(lines)+'\n',encoding='utf-8')
+    print(json.dumps(dict(status='passed',files=len(files),episodes=sum(r['episodes'] for r in descriptive),comparisons=len(comparisons)),ensure_ascii=False))
+
+if __name__=='__main__':main()

Upload/01_Source_Code/Python_Evaluation/RevisionAdditional_20260911/Tools/audit_additional.py

@@ -0,0 +1,124 @@
+"""Verify preservation and completed experiment provenance without changing raw data."""
+import argparse
+import difflib
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+TASK = Path(__file__).resolve().parents[1]
+ROOT = TASK.parents[1]
+OLD = ROOT / 'Document/RevisionEvaluation_Local_20260910'
+
+
+def load(p):
+    return json.loads(p.read_text(encoding='utf-8-sig'))
+
+
+def sha(p):
+    h = hashlib.sha256()
+    with p.open('rb') as f:
+        for block in iter(lambda: f.read(1024 * 1024), b''):
+            h.update(block)
+    return h.hexdigest()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--final', action='store_true')
+    args = parser.parse_args()
+    checks = []
+    original = load(OLD / 'Reports/original-project-sha256.json')
+    for r in original:
+        p = ROOT / r['path']
+        checks.append(dict(kind='original_project', path=str(p), passed=p.exists() and sha(p) == r['sha256']))
+    models = load(TASK / 'Reports/models-before-additional.json')
+    for r in models:
+        for base in [ROOT, ROOT / 'RevisionEval']:
+            p = base / r['path']
+            checks.append(dict(kind='model', path=str(p), passed=p.exists() and sha(p) == r['sha256']))
+        original_meta = ROOT / (r['path'] + '.meta')
+        copied_meta = ROOT / 'RevisionEval' / (r['path'] + '.meta')
+        checks.append(dict(kind='model_meta', path=str(copied_meta),
+                           passed=original_meta.exists() and copied_meta.exists() and sha(original_meta) == sha(copied_meta)))
+    old_summary = load(OLD / 'Reports/results-summary.json')
+    for phase, records in old_summary.items():
+        for r in records:
+            p = OLD / r['result']
+            checks.append(dict(kind='previous_result_' + phase, path=str(p), passed=p.exists() and sha(p) == r['sha256']))
+    source = []
+    patch = []
+    for r in load(TASK / 'Reports/pre-change-source-hashes.json'):
+        current = ROOT / r['path']
+        backup = TASK / 'Backups' / current.name
+        checks.append(dict(kind='source_backup', path=str(backup), passed=sha(backup) == r['sha256']))
+        source.append(dict(path=r['path'], before_sha256=r['sha256'], after_sha256=sha(current)))
+        patch.extend(difflib.unified_diff(backup.read_text(encoding='utf-8-sig').splitlines(True),
+                                        current.read_text(encoding='utf-8-sig').splitlines(True),
+                                        fromfile='before/' + current.name, tofile=r['path']))
+    extra = ROOT / 'RevisionEval/Assets/Editor/RevisionEvaluation/AdditionalEvaluationTools.cs'
+    source.append(dict(path=str(extra.relative_to(ROOT)), before_sha256=None, after_sha256=sha(extra)))
+    (TASK / 'Reports/source-changes.patch').write_text(''.join(patch), encoding='utf-8')
+    completed = []
+    configurations = []
+    jobs = load(TASK / 'Reports/job-manifest.json')
+    for j in jobs:
+        config = TASK / 'Jobs' / (j['id'] + '.json')
+        checks.append(dict(kind='configuration_matches_manifest', path=str(config), passed=load(config) == j))
+        configurations.append(dict(path=str(config.relative_to(TASK)), sha256=sha(config)))
+        report = Path(j['report'])
+        if not report.exists():
+            if args.final:
+                checks.append(dict(kind='job', path=str(report), passed=False))
+            continue
+        validation = TASK / 'Reports' / (j['id'] + '-validation.json')
+        exit_code = TASK / 'Reports' / (j['id'] + '-exit-code.txt')
+        if not args.final and (load(report)['status'] == 'running' or not exit_code.exists() or not validation.exists()):
+            continue
+        ok = (load(report)['status'] == 'passed' and validation.exists() and
+              load(validation)['status'] == 'passed' and exit_code.exists() and
+              exit_code.read_text(encoding='utf-8-sig').strip() == '0')
+        checks.append(dict(kind='job', path=str(report), passed=ok))
+        if ok:
+            completed.append(j['id'])
+            actual = load(report)['job']
+            checks.append(dict(kind='executed_configuration', path=str(report),
+                               passed=all(actual[k] == v for k, v in j.items() if k in actual)))
+    raw = []
+    for p in sorted((TASK / 'Results').rglob('*.json')):
+        d = load(p)
+        if 'all_wins' in d:
+            raw.append(dict(path=str(p.relative_to(TASK)), sha256=sha(p), episodes=d['episodes'],
+                            phase=d['evaluation']['experiment_kind']))
+    if args.final:
+        for name in ['additional-verification-retry1.json', 'pytorch-additional-parity.json',
+                     'onnxruntime-vs-recorded-unity.json', 'existing-statistics.json', 'heldout-statistics.json',
+                     'bc-diagnostic-effect.json', 'rtg-statistics.json', 'heldout-reward-components.json']:
+            p = TASK / 'Reports' / name
+            checks.append(dict(kind='analysis_or_verification', path=str(p), passed=p.exists() and load(p)['status'] == 'passed'))
+        checks.append(dict(kind='total_episodes', passed=sum(r['episodes'] for r in raw) == 2610))
+        checks.append(dict(kind='total_files', passed=len(raw) == 27))
+        for phase in ['bc-diagnostic', 'rtg', 'heldout', 'timing']:
+            p = TASK / 'Reports' / (phase + '-phase.json')
+            checks.append(dict(kind='phase', path=str(p), passed=p.exists() and load(p)['status'] == 'passed'))
+        p = TASK / 'Reports/latency-benchmark.json'
+        bench = load(p) if p.exists() else {}
+        checks.append(dict(kind='latency_benchmark', path=str(p), passed=bench.get('status') == 'passed' and
+                          len(bench.get('models', [])) == 3 and
+                          all(r['measurements'] == len(r['raw_ms']) == 2000 and r['warmup'] == 200 for r in bench.get('models', []))))
+    result = dict(status='passed' if all(c['passed'] for c in checks) else 'failed',
+                  mode='final' if args.final else 'interim', utc=datetime.now(timezone.utc).isoformat(),
+                  original_files=len(original), unchanged_models_per_project=len(models),
+                  previous_result_files=sum(map(len, old_summary.values())), completed_jobs=completed,
+                  result_files=len(raw), result_episodes=sum(r['episodes'] for r in raw),
+                  failed_checks=[c for c in checks if not c['passed']], checks=checks, sources=source,
+                  configuration_hash_timing='Recorded at audit; configurations were written before evaluations and checked against their manifest and Unity run reports.',
+                  configurations=configurations, raw_results=raw)
+    out = TASK / 'Reports' / ('final-audit.json' if args.final else 'interim-audit.json')
+    out.write_text(json.dumps(result, indent=2), encoding='utf-8')
+    print(json.dumps({k:v for k,v in result.items() if k not in ['checks', 'sources', 'raw_results', 'completed_jobs', 'configurations']}))
+    assert result['status'] == 'passed'
+
+
+if __name__ == '__main__':
+    main()

Upload/01_Source_Code/Python_Evaluation/RevisionAdditional_20260911/Tools/fetch_reference_weights.py

@@ -0,0 +1,37 @@
+"""Download pinned public weight files only. Remote Python is never executed."""
+import hashlib,json,urllib.request,urllib.parse,zipfile
+from pathlib import Path
+from inspect_public_data import RemoteZip
+TASK=Path(__file__).resolve().parents[1]
+ROOT=TASK.parents[1]
+
+def main():
+    inventory=json.loads((TASK/'Reports/public-data-inventory.json').read_text(encoding='utf-8-sig'))
+    archives=json.loads((TASK/'Reports/public-archive-inventory.json').read_text())
+    prefix='https://huggingface.co/code3939/DecisionTransformer-Unity-Sim/resolve/'+archives['revision']+'/'
+    out=TASK/'Verification/Weights';out.mkdir(exist_ok=True)
+    manifest=[]
+    for epoch in [1,2,3]:
+        name=f'E_{epoch}_DT_BC_100'
+        onnx=next(i for i in inventory if i['path']==f'DT Update/OnnxModels/{name}.onnx')
+        local=ROOT/f'RevisionEval/Assets/Model/FinalModel/BCModels/{name}.onnx'
+        assert hashlib.sha256(local.read_bytes()).hexdigest()==onnx['lfs']['oid']
+        pth=next(i for i in inventory if i['path']==f'DT Update/OnnxModels/{name}.pth')
+        with urllib.request.urlopen(prefix+urllib.parse.quote(pth['path']),timeout=30) as r:b=r.read(pth['size']+1)
+        digest=hashlib.sha256(b).hexdigest();assert len(b)==pth['size'] and digest==pth['lfs']['oid']
+        target=out/f'{name}.pth';assert not target.exists();target.write_bytes(b)
+        manifest.append(dict(model=name,path=str(target.relative_to(TASK)),sha256=digest,source=pth['path'],revision=archives['revision']))
+        print('Fetched and verified',name,flush=True)
+    archive=next(i for i in archives['archives'] if i['name']=='DT Models.zip')
+    remote=RemoteZip(prefix+urllib.parse.quote(archive['name']),archive['size'])
+    with zipfile.ZipFile(remote) as z:
+        onnx=z.read('E_3_DT_S_100.onnx')
+        assert hashlib.sha256(onnx).hexdigest()==hashlib.sha256((ROOT/'RevisionEval/Assets/Model/FinalModel/E_3_DT_S_100.onnx').read_bytes()).hexdigest()
+        b=z.read('E_3_DT_S_100.pth')
+    target=out/'E_3_DT_S_100.pth';assert not target.exists();target.write_bytes(b)
+    manifest.append(dict(model='E_3_DT_S_100',path=str(target.relative_to(TASK)),sha256=hashlib.sha256(b).hexdigest(),
+                         source='DT Models.zip/E_3_DT_S_100.pth',revision=archives['revision']))
+    (TASK/'Reports/reference-weight-manifest.json').write_text(json.dumps(manifest,indent=2),encoding='utf-8')
+    print('Fetched and verified E_3_DT_S_100; paired public ONNX matches local SHA256',flush=True)
+
+if __name__=='__main__':main()

Upload/01_Source_Code/Python_Evaluation/RevisionAdditional_20260911/Tools/inspect_public_data.py

@@ -0,0 +1,45 @@
+"""Read public archive directory via HTTP Range; no pickle deserialization or remote code."""
+import io,json,urllib.request,urllib.parse,zipfile
+from pathlib import Path
+TASK=Path(__file__).resolve().parents[1]
+REPO='https://huggingface.co/code3939/DecisionTransformer-Unity-Sim'
+
+class RemoteZip(io.RawIOBase):
+    def __init__(self,url,size):self.url=url;self.size=size;self.pos=0;self.bytes_read=0
+    def seekable(self):return True
+    def readable(self):return True
+    def tell(self):return self.pos
+    def seek(self,offset,whence=0):
+        self.pos=offset if whence==0 else self.pos+offset if whence==1 else self.size+offset
+        return self.pos
+    def read(self,n=-1):
+        if n<0:n=self.size-self.pos
+        n=min(n,self.size-self.pos)
+        if not n:return b''
+        if n>32*1024*1024:raise ValueError('Unexpected large metadata read')
+        end=self.pos+n-1
+        req=urllib.request.Request(self.url,headers={'Range':f'bytes={self.pos}-{end}'})
+        with urllib.request.urlopen(req,timeout=30) as r:
+            if r.status!=206 or not r.headers.get('Content-Range','').startswith(f'bytes {self.pos}-{end}/'):
+                raise ValueError('Server did not honor exact byte range')
+            b=r.read(n+1)
+        if len(b)!=n:raise ValueError('Wrong byte count')
+        self.pos+=n;self.bytes_read+=n;return b
+
+def main():
+    with urllib.request.urlopen('https://huggingface.co/api/models/code3939/DecisionTransformer-Unity-Sim',timeout=30) as r:meta=json.load(r)
+    revision=meta['sha']
+    inventory=json.loads((TASK/'Reports/public-data-inventory.json').read_text(encoding='utf-8-sig'))
+    out=dict(revision=revision,archives=[])
+    for name in ['DT TrajectoryData.zip','DT Models.zip']:
+        item=next(v for v in inventory if v['path']==name)
+        url=REPO+'/resolve/'+revision+'/'+urllib.parse.quote(name)
+        remote=RemoteZip(url,item['size'])
+        with zipfile.ZipFile(remote) as z:
+            entries=[dict(name=i.filename,size=i.file_size,compressed=i.compress_size,offset=i.header_offset,crc=i.CRC) for i in z.infolist()]
+        out['archives'].append(dict(name=name,sha256=item['lfs']['oid'],size=item['size'],metadata_bytes_read=remote.bytes_read,entries=entries))
+        print(name, len(entries),'entries',sum(i['size'] for i in entries),'uncompressed bytes',flush=True)
+        for i in entries[:50]:print(i,flush=True)
+    (TASK/'Reports/public-archive-inventory.json').write_text(json.dumps(out,indent=2),encoding='utf-8')
+
+if __name__=='__main__':main()

Upload/01_Source_Code/Python_Evaluation/RevisionAdditional_20260911/Tools/prepare_additional.py

@@ -0,0 +1,72 @@
+import hashlib
+import json
+from pathlib import Path
+import numpy as np
+import onnxruntime as ort
+
+TASK=Path(__file__).resolve().parents[1]
+ROOT=TASK.parents[1]
+OLD=ROOT/'Document/RevisionEvaluation_Local_20260910'
+PROJECT=ROOT/'RevisionEval'
+PPO='Assets/Model/V12/V12 PPO.onnx'
+DT='Assets/Model/FinalModel/E_3_DT_S_100.onnx'
+BC='Assets/Model/FinalModel/BCModels/E_3_DT_BC_100.onnx'
+
+def save(path,value):
+    assert not path.exists(), str(path)
+    path.write_text(json.dumps(value,indent=2),encoding='utf-8')
+
+def main():
+    inventory=json.loads((OLD/'Reports/model-inventory.json').read_text(encoding='utf-8'))
+    paths={Path(r['path']).stem:r['path'] for r in inventory}
+    sessions={}; cases=[]; maximum=0.
+    for file in sorted((OLD/'Results/full/transformers').rglob('*.json')):
+        data=json.loads(file.read_text(encoding='utf-8')); meta=data['evaluation']; name=meta['model_name']
+        if meta['policy_type']!='BC' and name!='E_3_DT_S_100': continue
+        model=paths[name]
+        if model not in sessions:
+            opt=ort.SessionOptions(); opt.intra_op_num_threads=2;opt.inter_op_num_threads=1
+            sessions[model]=ort.InferenceSession(str(PROJECT/model),sess_options=opt,providers=['CPUExecutionProvider'])
+        for t in meta['input_traces']:
+            inp={k:np.asarray(t[k],dtype=np.int32 if k=='timesteps' else np.float32).reshape(shape)
+                 for k,shape in [('observations',(1,32,9)),('actions',(1,32,3)),('returns_to_go',(1,32,1)),('timesteps',(1,32))]}
+            out=sessions[model].run(['predicted_actions'],inp)[0]
+            selected=out[0,t['valid_length']-1]
+            error=float(np.max(np.abs(selected-np.asarray(t['selected_action'])))); maximum=max(maximum,error)
+            assert np.allclose(selected,t['selected_action'],atol=1e-4,rtol=1e-4), (file,t['timestep'],error)
+            case=dict(model=model, sha256=hashlib.sha256((PROJECT/model).read_bytes()).hexdigest(),
+                label=f"{name}/targets={meta['target_count']}/episode={t['episode']}/t={t['timestep']}",
+                valid_length=t['valid_length'],expected_output=out.reshape(-1).tolist(),
+                **{k:t[k] for k in ('observations','actions','returns_to_go','timesteps')})
+            cases.append(case)
+    assert len(cases)==96 and len(sessions)==4
+    save(TASK/'Verification/actual-input-parity.json',dict(cases=cases))
+    save(TASK/'Reports/onnxruntime-vs-recorded-unity.json',dict(status='passed',cases=96,models=4,
+          ort=ort.__version__,maximum_absolute_selected_error=maximum,scope='Actual recorded traces, no BC PyTorch weights.'))
+    jobs=[]
+    def job(id,phase,models,targets,episodes,seed,rtg,**extra):
+        d=dict(id=id,phase=phase,policy='PPO' if models==[PPO] else 'DT',models=models,
+            scene=f'Assets/Scenes/RevisionEvaluation/{id}.unity',output=str(TASK/'Results'/phase/id),
+            report=str(TASK/'Reports'/f'{id}.json'),episodes=episodes,targets=targets,seed=seed,
+            max_steps=1000,initial_rtg=rtg,timeout_seconds=43200,experiment_kind=phase,**extra)
+        save(TASK/'Jobs'/f'{id}.json',d);jobs.append(d)
+    job('bc-normal','bc-diagnostic',[BC],20,50,42,0)
+    job('bc-legacy-rtg','bc-diagnostic',[BC],20,50,42,0,bc_legacy_rtg=True)
+    for rtg in range(0,111,10):
+        job(f'rtg-{rtg:03}','rtg',[DT],20,50,2000,rtg,rtg_sensitivity=True)
+    job('rtg-bc-reference','rtg',[BC],20,50,2000,0)
+    for targets,rtg in [(10,35),(15,55),(20,70)]:
+        job(f'heldout-{targets}-ppo','heldout',[PPO],targets,200,1000,rtg)
+        job(f'heldout-{targets}-dt-bc','heldout',[DT,BC],targets,200,1000,rtg)
+    job('timing-dt-bc','timing',[DT,BC],20,20,3000,70,record_timing=True,time_scale_override=1.)
+    job('timing-ppo','timing',[PPO],20,20,3000,70,record_timing=True,time_scale_override=1.)
+    save(TASK/'Reports/job-manifest.json',jobs)
+    hashes=[]
+    for row in inventory:
+        hash=hashlib.sha256((PROJECT/row['path']).read_bytes()).hexdigest()
+        assert hash==row['sha256']
+        hashes.append(dict(path=row['path'],sha256=hash))
+    save(TASK/'Reports/models-before-additional.json',hashes)
+    print(dict(parity_cases=96,models=4,max_error=maximum,jobs=len(jobs),new_episodes=sum(j['episodes']*len(j['models']) for j in jobs)))
+
+if __name__=='__main__':main()

Upload/01_Source_Code/Python_Evaluation/RevisionAdditional_20260911/Tools/progress.py

@@ -0,0 +1,18 @@
+import json,re
+from pathlib import Path
+TASK=Path(__file__).resolve().parents[1]
+jobs=json.loads((TASK/'Reports/job-manifest.json').read_text(encoding='utf-8'))
+done=[];active=[]
+for job in jobs:
+    report=Path(job['report'])
+    if report.exists():
+        r=json.loads(report.read_text(encoding='utf-8-sig'))
+        if r['status']=='passed':done.append(job);continue
+        path=TASK/'Logs'/f'{job["id"]}.log'
+        with path.open('rb') as f:
+            f.seek(max(0,path.stat().st_size-150000));s=f.read().decode('utf-8',errors='replace')
+        matches=re.findall(r'Episode (\d+)/(\d+) Finished\. Reward: ([^\r\n]+)',s)
+        active.append(dict(job=job['id'],status=r['status'],recent_episode=matches[-1] if matches else None,
+                           last_error=r.get('error','')))
+print(json.dumps(dict(completed_jobs=len(done),completed_episodes=sum(j['episodes']*len(j['models']) for j in done),
+                     total_jobs=len(jobs),planned_episodes=sum(j['episodes']*len(j['models']) for j in jobs),active=active),ensure_ascii=False))

Upload/01_Source_Code/Python_Evaluation/RevisionAdditional_20260911/Tools/report_additional.py

@@ -0,0 +1,100 @@
+import hashlib,json
+from pathlib import Path
+import numpy as np
+from scipy import stats
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+from analyze_statistics import mean_ci
+
+TASK=Path(__file__).resolve().parents[1]
+ROOT=TASK.parents[1]
+
+def load(p):return json.loads(p.read_text(encoding='utf-8-sig'))
+def save(p,x):p.write_text(json.dumps(x,indent=2),encoding='utf-8')
+def ci(k,n):
+    c=stats.binomtest(k,n).proportion_ci(method='exact');return [100*c.low,100*c.high]
+def main():
+    rows=[]
+    for p in sorted((TASK/'Results').rglob('*.json')):
+        d=load(p)
+        if 'all_wins' not in d:continue
+        m=d['evaluation'];n=d['episodes'];k=sum(d['all_wins'])
+        rows.append(dict(file=str(p.relative_to(TASK)),sha256=hashlib.sha256(p.read_bytes()).hexdigest(),
+            phase=m['experiment_kind'],model=m['model_name'],policy=m['policy_type'],targets=m['target_count'],
+            initial_rtg=m['initial_rtg'],diagnostic=m.get('diagnostic_only',False),episodes=n,successes=k,
+            success_percent=100*k/n,success_ci95_percent=ci(k,n),mean_steps=float(np.mean(d['all_steps'])),
+            mean_reward=float(np.mean(d['all_rewards'])),reward_ci95=mean_ci(d['all_rewards'],str(p)),
+            mean_smoothness=float(np.mean(d['all_smoothness'])),
+            mean_actual_accuracy=float(np.mean(d['all_actual_firing_accuracies'])),
+            mean_request_accuracy=float(np.mean(d['all_accuracies'])),
+            failures=[dict(seed=m['episode_seeds'][i],steps=d['all_steps'][i],
+                           remaining_targets=m['target_count']-m['episode_shots_hit'][i],reward=d['all_rewards'][i])
+                      for i,w in enumerate(d['all_wins']) if not w] ))
+    save(TASK/'Reports/additional-results-summary.json',rows)
+    rtg=sorted([r for r in rows if r['phase']=='rtg' and r['policy']=='DT'],key=lambda r:r['initial_rtg'])
+    bc=[r for r in rows if r['phase']=='rtg' and r['policy']=='BC']
+    if len(rtg)==12 and len(bc)==1:
+        b=bc[0];fig,axes=plt.subplots(1,2,figsize=(11,4.2),layout='constrained')
+        for ax,metric,interval,label in [(axes[0],'success_percent','success_ci95_percent','Success rate (%)'),
+                                        (axes[1],'mean_reward','reward_ci95','Mean cumulative reward')]:
+            x=np.array([r['initial_rtg'] for r in rtg]);y=np.array([r[metric] for r in rtg])
+            bounds=np.array([r[interval] for r in rtg])
+            ax.errorbar(x,y,yerr=np.vstack([y-bounds[:,0],bounds[:,1]-y]),fmt='o-',color='#1767ab',capsize=3,label='DT S100 E3')
+            ax.axhline(b[metric],color='#d87818',linestyle='--',label='BC100 E3 (always zero RTG)')
+            ax.axhspan(*b[interval],color='#d87818',alpha=.12)
+            ax.set(xlabel='Initial DT return-to-go',ylabel=label);ax.grid(alpha=.2);ax.legend(fontsize=8)
+        axes[0].set_ylim(-3,105)
+        fig.suptitle('20 targets | 50 paired episodes per setting | seeds 2000–2049\n95% marginal confidence intervals; fixed checkpoints')
+        fig.savefig(TASK/'Reports/rtg-sensitivity.png',dpi=180);plt.close(fig)
+    timing=[]
+    for p in (TASK/'Results/timing').rglob('*.json'):
+        d=load(p);m=d['evaluation']
+        assert m['timing_enabled']
+        if m['policy_type'] in ['DT','BC']:
+            assert len(m['control_loop_ms'])==len(m['inference_call_ms'])
+            assert np.all(np.asarray(m['control_loop_ms'])>=np.asarray(m['inference_call_ms']))
+        for key in ['inference_call_ms','control_loop_ms']:
+            a=np.asarray(m.get(key,[]),dtype=float)
+            if not len(a):continue
+            assert len(a)==sum(d['all_steps'])
+            assert len(a)>=2200,(p,len(a))
+            assert np.all(np.isfinite(a)) and np.all(a>0)
+            x=a[200:2200]
+            timing.append(dict(model=m['model_name'],metric=key,warmup_excluded=200,samples=2000,
+                available_actions=len(a),mean_ms=float(x.mean()),median_ms=float(np.median(x)),
+                p95_ms=float(np.quantile(x,.95,method='inverted_cdf')),scope=m['control_timing_scope']))
+    save(TASK/'Reports/control-timing-summary.json',timing)
+    lines=['# 추가 실험 결과','','이 문서는 완료된 추가 실행만 집계한다. 기존 2,850회와 합산하지 않는다. 온라인 Transformer 학습은 범위에서 제외했다.',
+           f"완료 결과: {len(rows)}개 파일, {sum(r['episodes'] for r in rows):,} 에피소드. 진단·RTG 민감도·새 환경 seed·timing은 각각 별도 조건이다.", '',
+           '[핵심 해석과 논문 수정 영향](INTERPRETATION_KO.md), [최종 보존·실행 검증](Reports/final-audit.json).', '',
+           '정상 DT는 표의 초기 RTG에서 시작해 매 step 보상을 차감한다. 정상 BC는 모든 step의 RTG 입력을 0으로 고정한다. PPO는 RTG 입력을 사용하지 않는다. BC legacy 조건만 초기 0 이후 보상을 차감하는 진단이다.', '',
+           '| 실험 | 표적 | 모델 | 초기 RTG | 성공/평가 | 성공률 정확 95% CI | 평균 종료 step | 평균 보상 |',
+           '|---|---:|---|---:|---:|---|---:|---:|']
+    for r in rows:
+        lo,hi=r['success_ci95_percent'];phase=r['phase']+(' (진단 전용)' if r['diagnostic'] else '')
+        rtg_text='해당 없음' if r['policy']=='PPO' else str(r['initial_rtg'])
+        lines.append(f"| {phase} | {r['targets']} | {r['model']} | {rtg_text} | {r['successes']}/{r['episodes']} | {lo:.2f}–{hi:.2f}% | {r['mean_steps']:.2f} | {r['mean_reward']:.4f} |")
+    lines+=['','## 새 환경 seed의 실패 사례','','개별 실패 seed·종료 step·남은 표적·보상은 Reports/additional-results-summary.json의 failures에 기록한다.','',
+            '| 표적 | 모델 | 실패 seed |','|---:|---|---|']
+    for r in rows:
+        if r['phase']=='heldout':
+            seeds=', '.join(str(f['seed']) for f in r['failures']) or '관측 없음'
+            lines.append(f"| {r['targets']} | {r['model']} | {seeds} |")
+    lines+=['','## 실제 제어 loop 측정','','첫 200 action을 제외한 다음 2,000 action. 에피소드 종료·파일 저장은 측정 구간 밖이다. PPO는 ML-Agents scheduling을 포함하며 DT와 호출 경계가 완전히 같지는 않다.','',
+            '| 모델 | 범위 | 평균 ms | 중앙값 ms | p95 ms |','|---|---|---:|---:|---:|']
+    for r in timing:lines.append(f"| {r['model']} | {r['metric']} | {r['mean_ms']:.3f} | {r['median_ms']:.3f} | {r['p95_ms']:.3f} |")
+    bench=TASK/'Reports/latency-benchmark.json'
+    if bench.exists() and load(bench)['status']=='passed':
+        lines+=['','## 모델 호출 단독 측정','','모델별 200회 warmup 후 2,000회. GPU 출력 readback 완료까지 포함한다. DT/BC GPU와 PPO CPU를 사용하며 모델 구조·장치 차이를 분리한 인과 비교는 아니다. 기존 사용자 Unity 프로세스는 유지했으므로 장치 독점 측정으로 해석하지 않는다.','',
+                '| 모델 | Backend | 평균 ms | 중앙값 ms | p95 ms |','|---|---|---:|---:|---:|']
+        for r in load(bench)['models']:lines.append(f"| {Path(r['model']).stem} | {r['backend']} | {r['mean_ms']:.3f} | {r['median_ms']:.3f} | {r['p95_ms']:.3f} |")
+    lines+=['','## 해석 범위','','고정된 가중치에서의 평가다. E1/E2/E3는 epoch별 체크포인트이며 독립 학습 seed 반복으로 간주하지 않는다. BC legacy RTG는 입력 불일치의 진단용이며 정상 BC 성능으로 보고하지 않는다. RTG curve는 행동 조건화 검사이며 BC보다 RTG가 필수적이라는 증명이 아니다.','',
+            '새 환경 seed는 이전 평가 42–91과 분리된 1000–1199이다. 환경 생성 분포는 같고, 원본 S 데이터와의 상태 비중복을 입증한 분포 외 평가로 해석하지 않는다.', '',
+            'CI는 개별 구간이다. 연속 지표 비교의 paired permutation 가정과 Holm 보정 범위는 통계 보고서를 참조한다. 비유의 차이는 동등성 증명이 아니다. Editor timing에서 실제 배포 빌드의 렌더링 FPS를 추론하지 않는다.', '',
+            '독립 학습 seed 반복은 원본 S 데이터 trajectory_data_part_*.pkl의 위치 확인이 필요하여 미실행이다. 환경 seed 평가 1,800회로 이를 대체했다고 주장하지 않는다.', '',
+            '관련 기록: [실행 계획](PROTOCOL_KO.md), [작업 기록](WORK_LOG_KO.md), [기존 평가 통계](existing_STATISTICS_KO.md), [새 환경 seed 통계](heldout_STATISTICS_KO.md), [RTG 그림](Reports/rtg-sensitivity.png), [RTG 통계](Reports/rtg-statistics.json), [BC 원인 진단 통계](Reports/bc-diagnostic-effect.json).']
+    (TASK/'RESULTS_KO.md').write_text('\n'.join(lines)+'\n',encoding='utf-8')
+    print(dict(files=len(rows),episodes=sum(r['episodes'] for r in rows),rtg_conditions=len(rtg),control_timing_rows=len(timing)))
+
+if __name__=='__main__':main()

Upload/01_Source_Code/Python_Evaluation/RevisionAdditional_20260911/Tools/run_additional.py

@@ -0,0 +1,93 @@
+"""Sequential, restartable runner. Each successful job is validated before continuing."""
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import subprocess
+import sys
+from datetime import datetime,timezone
+import validate_additional
+
+TASK=Path(__file__).resolve().parents[1]
+ROOT=TASK.parents[1]
+PHASES=['bc-diagnostic','rtg','heldout','timing']
+
+def load(p):return json.loads(p.read_text(encoding='utf-8-sig'))
+def save(p,d):p.write_text(json.dumps(d,indent=2),encoding='utf-8')
+def utc():return datetime.now(timezone.utc).isoformat()
+
+def invoke(mode,name,job=None):
+    command=['powershell.exe','-NoProfile','-File',str(TASK/'Tools/Run-Unity.ps1'),'-Mode',mode,'-RunName',name]
+    if job:command+=['-JobPath',str(TASK/'Jobs'/f'{job["id"]}.json')]
+    print(f'{utc()} Starting {name}',flush=True)
+    result=subprocess.run(command)
+    assert result.returncode==0, f'{name}: process exit {result.returncode}'
+    report=load(Path(job['report']) if job else TASK/'Reports'/f'{name}.json')
+    assert report['status']=='passed',report
+
+def validate_job(job):
+    errors,warnings,rows=validate_additional.validate(job['output'],job['episodes'],len(job['models']),[job['targets']],
+        job.get('rtg_sensitivity',False),job.get('bc_legacy_rtg',False))
+    save(TASK/'Reports'/f'{job["id"]}-validation.json',dict(status='passed' if not errors else 'failed',errors=errors,warnings=warnings,files=len(rows)))
+    assert not errors,errors
+    return rows
+
+def bc_diagnostic_summary():
+    def one(root):
+        files=list(root.rglob('*.json'));assert len(files)==1
+        return load(files[0])
+    a=one(TASK/'Results/bc-diagnostic/bc-normal');b=one(TASK/'Results/bc-diagnostic/bc-legacy-rtg')
+    oldfiles=list((ROOT/'Document/RevisionEvaluation_Local_20260910/Results/full/transformers/20').rglob('*E_3_DT_BC_100.json'))
+    assert len(oldfiles)==1
+    old=load(oldfiles[0])
+    checks={k:a[k]==old[k] for k in ['all_wins','all_steps','all_rewards','all_smoothness','all_accuracies','all_actual_firing_accuracies']}
+    assert all(checks.values()),f'Normal BC behavior changed: {checks}'
+    for key in ['episode_seeds','initial_states','initial_state_sha256']:
+        assert a['evaluation'][key]==b['evaluation'][key]==old['evaluation'][key]
+    summary=dict(status='passed',normal_reproduces_previous=checks,scope='Only RTG update differs; diagnostic is not a valid BC benchmark',
+        normal=dict(successes=sum(a['all_wins']),mean_steps=a['avg_steps'],reward=a['avg_reward']),
+        legacy=dict(successes=sum(b['all_wins']),mean_steps=b['avg_steps'],reward=b['avg_reward'],
+                    max_abs_rtg=max(b['evaluation']['max_abs_rtg_input'])))
+    save(TASK/'Reports/bc-diagnostic-summary.json',summary)
+    print(summary,flush=True)
+
+def run(phase):
+    jobs=[j for j in load(TASK/'Reports/job-manifest.json') if j['phase']==phase]
+    assert load(TASK/'Reports/additional-verification-retry1.json')['status']=='passed'
+    if PHASES.index(phase)>0:
+        assert load(TASK/'Reports'/f'{PHASES[PHASES.index(phase)-1]}-phase.json')['status']=='passed'
+    report_path=TASK/'Reports'/f'{phase}-phase.json'
+    report=dict(phase=phase,status='running',started_utc=utc(),jobs=[])
+    save(report_path,report)
+    try:
+        if phase=='timing' and not (TASK/'Reports/latency-benchmark.json').exists():
+            invoke('Latency','latency-benchmark')
+        for job in jobs:
+            path=Path(job['report'])
+            if not path.exists() or load(path)['status']!='passed':invoke('Run',job['id'],job)
+            validate_job(job)
+            report['jobs'].append(dict(id=job['id'],status='passed'))
+            save(report_path,report)
+            print(f'{utc()} Validated {job["id"]}',flush=True)
+        if phase=='bc-diagnostic':bc_diagnostic_summary()
+        else:
+            errors,warnings,rows=validate_additional.validate(TASK/'Results'/phase,
+                {'rtg':50,'heldout':200,'timing':20}[phase],{'rtg':2,'heldout':3,'timing':3}[phase],
+                [10,15,20] if phase=='heldout' else [20],phase=='rtg')
+            assert not errors,errors
+            report.update(result_files=len(rows),episodes=sum(r[2]['episodes'] for r in rows))
+        if phase=='heldout':
+            result=subprocess.run([sys.executable,str(TASK/'Tools/analyze_statistics.py'),str(TASK/'Results/heldout'),'heldout'])
+            assert result.returncode==0
+        report.update(status='passed',finished_utc=utc())
+    except Exception as e:
+        report.update(status='failed',error=str(e),finished_utc=utc())
+        save(report_path,report)
+        raise
+    save(report_path,report)
+
+def main():
+    p=argparse.ArgumentParser();p.add_argument('phase',choices=PHASES+['all']);a=p.parse_args()
+    for phase in PHASES if a.phase=='all' else [a.phase]:run(phase)
+
+if __name__=='__main__':main()

Upload/01_Source_Code/Python_Evaluation/RevisionAdditional_20260911/Tools/validate_additional.py

@@ -0,0 +1,185 @@
+"""Validate aligned-evaluation-v2.1 JSON logs. Python 3 standard library only; never edits logs."""
+import argparse
+from collections import defaultdict
+import json
+import math
+from pathlib import Path
+
+PROTOCOL = 'aligned-evaluation-v2.1'
+REWARD = 'ShootingAgent-shaped-angle-v1'
+SEQUENCE = 'dataset-shifted-action-right-pad32-v2'
+ACCURACY = 'hits-per-fire-request-percent-v1'
+
+def number(v):
+    return isinstance(v, (int, float)) and not isinstance(v, bool) and math.isfinite(v)
+
+def close(a, b):
+    return number(a) and math.isclose(a, b, rel_tol=2e-5, abs_tol=2e-4)
+
+def validate(root, expected_episodes=50, expected_models=None, expected_targets=None, allow_rtg_sensitivity=False, allow_bc_diagnostic=False):
+    errors, warnings, results = [], [], []
+    for path in sorted(Path(root).rglob('*.json')):
+        try:
+            data = json.loads(path.read_text(encoding='utf-8-sig'))
+        except (ValueError, OSError) as exc:
+            errors.append(f'{path}: unreadable JSON: {exc}'); continue
+        if not isinstance(data, dict) or 'all_wins' not in data:
+            continue
+        meta = data.get('evaluation')
+        if not isinstance(meta, dict) or meta.get('protocol_version') != PROTOCOL:
+            errors.append(f'{path}: missing/current protocol metadata; do not mix old logs'); continue
+        label = f'{meta.get("target_count")}/{meta.get("model_name")}'
+        def fail(message): errors.append(f'{label}: {message}')
+        n = data.get('episodes')
+        if type(n) is not int or n < 1:
+            fail('invalid episode count'); continue
+        if n != expected_episodes or meta.get('episodes_requested') != n:
+            fail(f'expected {expected_episodes} episodes, got {n}')
+        policy = meta.get('policy_type')
+        diagnostic = meta.get('diagnostic_only', False)
+        if diagnostic and not allow_bc_diagnostic: fail('Diagnostic BC results are not normal evaluation results')
+        if diagnostic and (policy != 'BC' or meta.get('bc_legacy_rtg') is not True or meta.get('initial_rtg') != 0):
+            fail('Invalid legacy-BC diagnostic metadata')
+        if policy not in ('PPO', 'DT', 'BC'): fail('unknown policy type')
+        if type(meta.get('target_count')) is not int or meta['target_count'] <= 0:
+            fail('invalid target count'); continue
+        if not isinstance(meta.get('model_name'), str) or not meta['model_name']:
+            fail('missing model name')
+        if meta.get('reward_protocol') != REWARD: fail('reward protocol differs from common training-based reward')
+        if meta.get('accuracy_protocol') != ACCURACY: fail('accuracy protocol mismatch')
+        expected_sequence = 'PPO' if policy == 'PPO' else SEQUENCE
+        if meta.get('sequence_protocol') != expected_sequence: fail('sequence protocol mismatch')
+        expected_history = 'PPO' if policy == 'PPO' else 'raw-continuous-and-actual-fire-v1'
+        if meta.get('action_history_protocol') != expected_history: fail('action history protocol mismatch')
+        if meta.get('rtg_sensitivity') and not allow_rtg_sensitivity:
+            fail('RTG sensitivity run mixed with main evaluation; use a separate folder or --allow-rtg-sensitivity')
+        for key in ['fixed_delta_time', 'rotation_speed', 'shoot_distance']:
+            if not number(meta.get(key)) or meta[key] <= 0: fail(f'invalid setting {key}')
+        if not number(meta.get('step_penalty')): fail('invalid step penalty')
+        if not isinstance(meta.get('unity_version'), str) or not meta['unity_version']: fail('missing Unity version')
+        if type(meta.get('queries_hit_triggers')) is not bool: fail('missing physics trigger setting')
+        if type(meta.get('enemy_layer_mask')) is not int: fail('missing enemy layer mask')
+        limit = meta.get('max_action_steps')
+        if type(limit) is not int or limit < 1: fail('invalid step limit'); limit = 0
+        elif policy in ('DT', 'BC') and limit > 4096: fail('timestep capacity exceeded')
+
+        numeric_arrays = ['all_wins', 'all_rewards', 'all_steps', 'all_smoothness',
+                          'all_accuracies', 'all_actual_firing_accuracies']
+        valid_arrays = True
+        for key in numeric_arrays:
+            values = data.get(key)
+            if not isinstance(values, list) or len(values) != n or not all(number(v) for v in values):
+                fail(f'{key} invalid/length mismatch'); valid_arrays = False
+        counts_valid = True
+        for key in ['episode_action_steps', 'episode_shots_fired', 'episode_shots_hit', 'episode_raycasts']:
+            values = meta.get(key)
+            if not isinstance(values, list) or len(values) != n or not all(type(v) is int and v >= 0 for v in values):
+                fail(f'{key} invalid/length mismatch'); counts_valid = False
+        for key in ['episode_seeds', 'initial_states', 'initial_state_sha256']:
+            if not isinstance(meta.get(key), list) or len(meta[key]) != n: fail(f'{key} length mismatch')
+        master = meta.get('master_seed')
+        if type(master) is not int or meta.get('episode_seeds') != list(range(master, master + n)):
+            fail('seed schedule mismatch')
+        states = meta.get('initial_states')
+        if isinstance(states, list):
+            for i, state in enumerate(states):
+                if not isinstance(state, dict) or state.get('episode') != i + 1 or type(master) is not int or state.get('seed') != master + i:
+                    fail('initial_states episode/seed mismatch'); break
+                if not isinstance(state.get('targets'), list) or len(state['targets']) != meta['target_count']:
+                    fail('initial_states target count mismatch'); break
+        hashes = meta.get('initial_state_sha256')
+        if isinstance(hashes, list) and any(not isinstance(v, str) or len(v) != 64 or any(c not in '0123456789abcdef' for c in v) for v in hashes):
+            fail('invalid initial state hash')
+        if valid_arrays:
+            wins, steps, rewards = (data[k] for k in ('all_wins', 'all_steps', 'all_rewards'))
+            if not all(type(v) is int and v in (0, 1) for v in wins): fail('non-binary wins')
+            if not close(data.get('win_rate'), 100 * sum(wins) / n): fail('win_rate inconsistent')
+            if meta.get('episode_action_steps') != steps: fail('action counts differ from all_steps')
+            if any(type(v) is not int or not 1 <= v <= limit for v in steps): fail('step limit violated')
+            if any(w == 0 and step != limit for w, step in zip(wins, steps)): fail('failed episode ended before timeout')
+            if any(not 0 <= v <= 100 for k in ['all_accuracies', 'all_actual_firing_accuracies'] for v in data[k]): fail('accuracy outside 0-100')
+            if any(v < 0 for v in data['all_smoothness']): fail('negative smoothness')
+            mean = sum(rewards) / n
+            if not close(data.get('avg_reward'), mean): fail('avg_reward inconsistent')
+            if not close(data.get('avg_steps'), sum(steps) / n): fail('avg_steps inconsistent')
+            if not close(data.get('reward_std'), math.sqrt(sum((v-mean)**2 for v in rewards) / n)): fail('reward_std inconsistent with population SD')
+            if not close(data.get('smoothness'), sum(a*b for a,b in zip(data['all_smoothness'],steps))/max(1,sum(steps))):
+                fail('smoothness summary inconsistent with step-weighted aggregation')
+            if counts_valid:
+                requests, hits, casts = (meta[k] for k in ['episode_shots_fired','episode_shots_hit','episode_raycasts'])
+                for i, (req, hit, cast, step) in enumerate(zip(requests,hits,casts,steps)):
+                    if not 0 <= hit <= cast <= req <= step: fail(f'episode {i+1}: hit/raycast/request counts invalid')
+                    if hit > meta['target_count'] or (wins[i] == 1) != (hit == meta['target_count']): fail(f'episode {i+1}: hits inconsistent with success')
+                    if not close(data['all_accuracies'][i], 100*hit/req if req else 0): fail('per-episode request accuracy inconsistent')
+                    if not close(data['all_actual_firing_accuracies'][i], 100*hit/cast if cast else 0): fail('per-episode actual firing accuracy inconsistent')
+                if not close(data.get('accuracy'), 100*sum(hits)/sum(requests) if sum(requests) else 0): fail('accuracy summary inconsistent')
+                if not close(data.get('actual_firing_accuracy'), 100*sum(hits)/sum(casts) if sum(casts) else 0): fail('actual firing accuracy summary inconsistent')
+        if policy in ('BC', 'DT'):
+            values = meta.get('max_abs_rtg_input')
+            terminal = meta.get('episode_terminal_rtg')
+            initial = meta.get('initial_rtg')
+            rtg_valid = (number(initial) and isinstance(values,list) and len(values)==n and all(number(v) and v>=0 for v in values)
+                         and isinstance(terminal,list) and len(terminal)==n and all(number(v) for v in terminal))
+            if not rtg_valid: fail('RTG diagnostics invalid')
+            elif policy == 'BC' and not diagnostic:
+                if meta.get('bc_zero_rtg') is not True or initial != 0 or any(v != 0 for v in values + terminal): fail('BC RTG was not always zero')
+            else:
+                if meta.get('bc_zero_rtg') is not False: fail('DT incorrectly marked zero-RTG')
+                if valid_arrays and any(not math.isclose(t,initial-r,rel_tol=2e-4,abs_tol=0.02) for t,r in zip(terminal,data['all_rewards'])):
+                    fail('terminal RTG does not include the full episode reward')
+            traces = meta.get('input_traces', [])
+            if not isinstance(traces, list):
+                fail('invalid input_traces'); traces = []
+            for trace in traces:
+                if not isinstance(trace,dict): fail('invalid input trace'); continue
+                t, valid = trace.get('timestep'), trace.get('valid_length')
+                if type(t) is not int or t < 0 or valid != min(t+1,32): fail('trace valid length mismatch'); continue
+                expected = list(range(max(0,t-31), t+1)) + [0]*(32-valid)
+                if trace.get('timesteps') != expected: fail('trace absolute timesteps mismatch')
+                for key,dim in [('observations',9),('actions',3),('returns_to_go',1)]:
+                    a = trace.get(key)
+                    if not isinstance(a,list) or len(a)!=32*dim or not all(number(v) for v in a): fail(f'trace {key} invalid'); continue
+                    if any(v!=0 for v in a[valid*dim:]): fail('trace right padding is not zero')
+                    if key=='actions' and any(v not in (0,1) for v in a[2:valid*3:3]): fail('trace fire history is not binary')
+                    if key=='returns_to_go' and policy=='BC' and not diagnostic and any(v!=0 for v in a): fail('BC RTG trace drift')
+        results.append((label,path,data,meta))
+
+    if not results: errors.append('No evaluation results found')
+    by_target = defaultdict(list)
+    for row in results: by_target[row[3]['target_count']].append(row)
+    if expected_targets is not None and set(by_target) != set(expected_targets):
+        errors.append(f'Expected target conditions {sorted(expected_targets)}, found {sorted(by_target)}')
+    for target, rows in by_target.items():
+        identities = [(r[3].get('model_name'),r[3].get('initial_rtg'),r[3].get('policy_type')) for r in rows]
+        if len(set(identities)) != len(identities): errors.append(f'{target}: duplicate model/RTG runs; select one run per comparison')
+        models = {r[3].get('model_name') for r in rows}
+        if not allow_rtg_sensitivity and len(models) != len(rows): errors.append(f'{target}: more than one run for a model')
+        if expected_models is not None and len(models) != expected_models: errors.append(f'{target}: expected {expected_models} distinct models, got {len(models)}')
+        baseline = rows[0][3]
+        for label,path,data,meta in rows[1:]:
+            for key in ['episode_seeds','initial_states','initial_state_sha256','fixed_delta_time','max_action_steps',
+                        'rotation_speed','shoot_distance','step_penalty','enemy_layer_mask','unity_version','queries_hit_triggers',
+                        'reward_protocol','accuracy_protocol']:
+                if meta.get(key) != baseline.get(key): errors.append(f'{label}: paired condition mismatch: {key}')
+        if not allow_rtg_sensitivity:
+            rtgs = {r[3].get('initial_rtg') for r in rows if r[3].get('policy_type') == 'DT'}
+            if len(rtgs)>1: errors.append(f'{target}: DT models have different initial RTGs')
+    return errors,warnings,results
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('root',type=Path)
+    p.add_argument('--expected-episodes',type=int,default=50)
+    p.add_argument('--expected-models',type=int)
+    p.add_argument('--expected-targets',type=int,nargs='+')
+    p.add_argument('--allow-rtg-sensitivity',action='store_true')
+    p.add_argument('--allow-bc-diagnostic',action='store_true')
+    args=p.parse_args()
+    errors,warnings,rows=validate(args.root,args.expected_episodes,args.expected_models,args.expected_targets,args.allow_rtg_sensitivity,args.allow_bc_diagnostic)
+    for m in errors: print('ERROR:',m)
+    for m in warnings: print('WARNING:',m)
+    print(f'Checked {len(rows)} result files; {len(errors)} errors.')
+    if not errors: print('Protocol/seed/initial-state/metric checks passed. Model validity and statistical assumptions require separate assessment.')
+    raise SystemExit(1 if errors else 0)
+
+if __name__=='__main__': main()

Upload/01_Source_Code/Python_Evaluation/RevisionAdditional_20260911/Tools/verify_pytorch_weights.py

@@ -0,0 +1,36 @@
+import hashlib,importlib.util,json
+from pathlib import Path
+import numpy as np
+import torch
+TASK=Path(__file__).resolve().parents[1]
+ROOT=TASK.parents[1]
+
+def main():
+    source=ROOT/'Document/ShootingGame_IDE_Handoff/reference_originals/Python/model_dt.py'
+    spec=importlib.util.spec_from_file_location('verified_local_model_dt',source)
+    module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module)
+    torch.set_num_threads(2)
+    fixtures=json.loads((TASK/'Verification/actual-input-parity.json').read_text())['cases']
+    weights=json.loads((TASK/'Reports/reference-weight-manifest.json').read_text())
+    rows=[]
+    for w in weights:
+        path=TASK/w['path'];assert hashlib.sha256(path.read_bytes()).hexdigest()==w['sha256']
+        state=torch.load(path,map_location='cpu',weights_only=True)
+        model=module.DecisionTransformer(9,3,hidden=256,n_layers=4,n_heads=4,max_len=4096)
+        model.load_state_dict(state,strict=True);model.eval();count=0;maximum=0.
+        for c in fixtures:
+            if Path(c['model']).stem!=w['model']:continue
+            inputs=[torch.tensor(c[k],dtype=torch.long if k=='timesteps' else torch.float32).reshape(shape)
+                for k,shape in [('observations',(1,32,9)),('actions',(1,32,3)),('returns_to_go',(1,32,1)),('timesteps',(1,32))]]
+            with torch.no_grad():out=model(*inputs).numpy().reshape(-1)
+            expected=np.asarray(c['expected_output']);error=float(np.max(np.abs(out-expected)));maximum=max(maximum,error)
+            assert np.allclose(out,expected,atol=1e-4,rtol=1e-4),(c['label'],error)
+            count+=1
+        assert count==24
+        rows.append(dict(model=w['model'],cases=count,maximum_absolute_error=maximum,state_tensors=len(state),strict_load=True))
+    report=dict(status='passed',torch=torch.__version__,backend='CPU',models=rows,
+                source_sha256=hashlib.sha256(source.read_bytes()).hexdigest(),scope='96 actual inputs, PyTorch vs ONNX Runtime; independently checked against Unity GPU outputs.')
+    (TASK/'Reports/pytorch-additional-parity.json').write_text(json.dumps(report,indent=2))
+    print(json.dumps(report,indent=2))
+
+if __name__=='__main__':main()

Upload/01_Source_Code/Python_Evaluation/RevisionEvaluation_Local_20260910/Tools/Run-Unity.ps1

@@ -0,0 +1,28 @@
+param(
+    [ValidateSet('Verify','Run')][string]$Mode = 'Verify',
+    [string]$JobPath = '',
+    [string]$RunName = 'unity-verification'
+)
+$ErrorActionPreference = 'Stop'
+$taskRoot = Split-Path -Parent $PSScriptRoot
+$projectRoot = Join-Path (Split-Path -Parent (Split-Path -Parent $taskRoot)) 'RevisionEval'
+$editor = 'C:/Program Files/Unity/Hub/Editor/6000.0.62f1/Editor/Unity.exe'
+$editorArguments = @('-batchmode','-force-d3d11','-projectPath',('"'+$projectRoot+'"'),
+    '-executeMethod',('RevisionEvaluationBatch.'+$Mode),'-logFile',('"'+$taskRoot+'/Logs/'+$RunName+'.log"'))
+if ($Mode -eq 'Verify') {
+    $editorArguments += @('-evaluationFixtures',('"'+$taskRoot+'/Verification/E_1_DT_C_5_sequence_fixtures.json"'),
+        '-evaluationReport',('"'+$taskRoot+'/Reports/'+$RunName+'.json"'))
+} else {
+    $job = Get-Content -LiteralPath $JobPath -Raw -Encoding UTF8 | ConvertFrom-Json
+    $editorArguments += @('-evaluationJob',('"'+(Resolve-Path -LiteralPath $JobPath).Path+'"'),
+        '-evaluationOutput',('"'+$job.output+'"'))
+}
+$editorArguments | ConvertTo-Json | Set-Content -LiteralPath "$taskRoot/Reports/$RunName-command.json" -Encoding UTF8
+$taskProcess = Start-Process -FilePath $editor -ArgumentList $editorArguments -WindowStyle Hidden -PassThru
+$taskProcess.Id | Set-Content -LiteralPath "$taskRoot/Reports/$RunName.pid"
+Write-Output "$RunName Unity PID: $($taskProcess.Id)"
+$taskProcess.WaitForExit()
+$taskProcess.Refresh()
+$taskProcess.ExitCode | Set-Content -LiteralPath "$taskRoot/Reports/$RunName-exit-code.txt"
+Write-Output "$RunName exit code: $($taskProcess.ExitCode)"
+exit $taskProcess.ExitCode

Upload/01_Source_Code/Python_Evaluation/RevisionEvaluation_Local_20260910/Tools/capture_changes.py

@@ -0,0 +1,52 @@
+"""Capture the final working-copy changes and model-preservation evidence."""
+import difflib
+import hashlib
+import json
+from pathlib import Path
+
+task = Path(__file__).resolve().parents[1]
+source = task.parents[1]
+project = source / "RevisionEval"
+original = json.loads((task / "Reports/original-project-sha256.json").read_text(encoding="utf-8-sig"))
+
+
+def sha(path):
+    with path.open("rb") as stream:
+        return hashlib.file_digest(stream, "sha256").hexdigest()
+
+
+def read_source(path):
+    try:
+        return path.read_text(encoding="utf-8-sig")
+    except UnicodeDecodeError:
+        return path.read_text(encoding="cp949")
+
+
+baseline = {item["path"].replace("\\", "/"): item for item in original}
+changed, added, missing = [], [], []
+diff = []
+for name, item in baseline.items():
+    path = project / name
+    if not path.exists():
+        missing.append(name)
+    elif sha(path) != item["sha256"]:
+        changed.append(name)
+        if path.suffix in (".cs", ".json", ".asset", ".meta"):
+            diff.extend(difflib.unified_diff(read_source(source / name).splitlines(True),
+                                            read_source(path).splitlines(True),
+                                            fromfile="a/" + name, tofile="b/" + name))
+for folder in ("Assets", "Packages", "ProjectSettings"):
+    for path in (project / folder).rglob("*"):
+        if path.is_file() and path.relative_to(project).as_posix() not in baseline:
+            added.append(path.relative_to(project).as_posix())
+            if path.suffix == ".cs":
+                diff.extend(difflib.unified_diff([], path.read_text(encoding="utf-8-sig").splitlines(True),
+                                                fromfile="/dev/null", tofile="b/" + path.relative_to(project).as_posix()))
+data = {"working_project": str(project), "changed_existing": changed, "added": sorted(added),
+        "missing_existing": missing,
+        "existing_meta_changed": [name for name in changed if name.endswith(".meta")],
+        "model_files_changed": [name for name in changed if name.endswith((".onnx", ".pth", ".nn"))],
+        "training_script_unchanged": "Assets/Script/Shoodting/DroneAgent.cs" not in changed}
+(task / "Reports/working-copy-changes.json").write_text(json.dumps(data, indent=2), encoding="utf-8")
+(task / "INTEGRATION_DIFF.patch").write_text("".join(diff), encoding="utf-8")
+print(json.dumps({k: v for k, v in data.items() if k != "added"}, ensure_ascii=False))

Upload/01_Source_Code/Python_Evaluation/RevisionEvaluation_Local_20260910/Tools/finalize_report.py

@@ -0,0 +1,57 @@
+"""Check the complete model roster and consolidate existing validation evidence."""
+from collections import Counter
+from datetime import datetime
+import hashlib
+import json
+from pathlib import Path
+
+task = Path(__file__).resolve().parents[1]
+project = task.parents[1] / "RevisionEval"
+
+
+def load(relative):
+    return json.loads((task / relative).read_text(encoding="utf-8-sig"))
+
+
+phases = {name: load(f"Reports/{name}-phase.json") for name in ("smoke", "repeat", "full")}
+assert all(value["status"] == "passed" for value in phases.values())
+inventory = load("Reports/model-inventory.json")
+roster = {Path(model["path"]).stem for model in inventory}
+assert len(roster) == 19
+results = [json.loads(path.read_text()) for path in (task / "Results/full").rglob("*.json")]
+assert len(results) == 57 and sum(result["episodes"] for result in results) == 2850
+conditions = []
+for targets in (10, 15, 20):
+    subset = [r for r in results if r["evaluation"]["target_count"] == targets]
+    assert {r["evaluation"]["model_name"] for r in subset} == roster
+    assert Counter(r["evaluation"]["policy_type"] for r in subset) == {"PPO": 1, "DT": 15, "BC": 3}
+    conditions.append({"targets": targets, "models": len(subset), "episodes": sum(r["episodes"] for r in subset)})
+preservation = load("Reports/original-preservation.json")
+changes = load("Reports/working-copy-changes.json")
+assert not preservation["changed_or_missing"]
+assert not changes["model_files_changed"] and not changes["existing_meta_changed"] and changes["training_script_unchanged"]
+source_hashes = {name: hashlib.sha256((project / name).read_bytes()).hexdigest()
+                 for name in changes["changed_existing"] + changes["added"] if name.endswith(".cs")}
+parity = load("Verification_Local/model_verification.json")
+assert len(parity["tests"]) == 18 and all(case["passed"] for case in parity["tests"])
+unit_log = (task / "Logs/python-validator-tests.log").read_text()
+assert "Ran 19 tests" in unit_log and "\nOK\n" in unit_log
+full = phases["full"]
+summary = {"status": "passed", "protocol": "aligned-evaluation-v2.1",
+           "working_project": str(project), "result_files": 57, "episodes": 2850,
+           "conditions": conditions, "seed_first": 42, "seed_last": 91,
+           "started_utc": full["started_utc"], "finished_utc": full["finished_utc"],
+           "full_wall_seconds": (datetime.fromisoformat(full["finished_utc"]) - datetime.fromisoformat(full["started_utc"])).total_seconds(),
+           "python_validator_tests_passed": 19,
+           "python_model_parity_cases_passed": 18,
+           "python_model_parity_max_error": max(case["max_abs_error"] for case in parity["tests"]),
+           "unity_verification": load("Reports/unity-verification.json"),
+           "all_transformer_contracts": load("Reports/all-transformer-contracts.json"),
+           "reproducibility": load("Reports/reproducibility.json"),
+           "original_preservation": preservation, "source_files_sha256": source_hashes,
+           "limits": ["PyTorch/Unity parity covers E_1_DT_C_5 only.",
+                      "PPO retains stochastic inference: initial states repeat, steps/rewards need not.",
+                      "PPO Default uses CPU; DT/BC use GPUCompute. Wall time is not a latency comparison.",
+                      "No manuscript edits or inferential statistics were performed."]}
+(task / "Reports/local-validation-summary.json").write_text(json.dumps(summary, indent=2), encoding="utf-8")
+print("Final roster verified: 57 files, 2850 episodes, 19 exact models per target condition; original files preserved.")

Upload/01_Source_Code/Python_Evaluation/RevisionEvaluation_Local_20260910/Tools/prepare_jobs.py

@@ -0,0 +1,76 @@
+"""Record existing model identities and prepare explicit, reproducible Unity batch jobs."""
+import hashlib
+import json
+from pathlib import Path
+
+import onnx
+
+TASK = Path(__file__).resolve().parents[1]
+SOURCE = TASK.parents[1]
+PROJECT = SOURCE / "RevisionEval"
+HANDOFF = SOURCE / "Document/ShootingGame_IDE_Handoff"
+
+
+def write(path, value):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def sha(path):
+    with path.open("rb") as stream:
+        return hashlib.file_digest(stream, "sha256").hexdigest()
+
+
+def main():
+    expected = json.loads((HANDOFF / "FILES_SHA256.json").read_text(encoding="utf-8"))
+    failures = [name for name, digest in expected.items() if sha(HANDOFF / name) != digest]
+    write(TASK / "Reports/handoff-integrity.json", {"checked": len(expected), "mismatches": failures})
+    if failures:
+        raise RuntimeError(f"Handoff integrity failed: {failures}")
+
+    ppo = "Assets/Model/V12/V12 PPO.onnx"
+    dt = [f"Assets/Model/FinalModel/E_{exp}_DT_{kind}.onnx"
+          for exp in (1, 2, 3) for kind in ("C_5", "C_10", "S_100", "SC_5", "SC_10")]
+    bc = [f"Assets/Model/FinalModel/BCModels/E_{exp}_DT_BC_100.onnx" for exp in (1, 2, 3)]
+    inventory = []
+    for name in [ppo, *dt, *bc]:
+        path = PROJECT / name
+        model = onnx.load(path, load_external_data=False)
+        inputs = [{"name": v.name, "dtype": v.type.tensor_type.elem_type,
+                   "shape": [d.dim_value if d.HasField("dim_value") else d.dim_param
+                             for d in v.type.tensor_type.shape.dim]} for v in model.graph.input]
+        outputs = [{"name": v.name, "dtype": v.type.tensor_type.elem_type,
+                    "shape": [d.dim_value if d.HasField("dim_value") else d.dim_param
+                              for d in v.type.tensor_type.shape.dim]} for v in model.graph.output]
+        if name != ppo:
+            contract = {v["name"]: (v["dtype"], len(v["shape"])) for v in inputs}
+            assert contract == {"observations": (1, 3), "actions": (1, 3),
+                                "returns_to_go": (1, 3), "timesteps": (6, 2)}, (name, inputs)
+            assert [v["name"] for v in outputs] == ["predicted_actions"], (name, outputs)
+        inventory.append({"path": name, "sha256": sha(path), "bytes": path.stat().st_size,
+                          "inputs": inputs, "outputs": outputs})
+    write(TASK / "Reports/model-inventory.json", inventory)
+
+    def job(phase, name, models, targets=10, episodes=2):
+        identity = f"{phase}-{name}-{targets}"
+        value = {"id": identity, "policy": "PPO" if name == "ppo" else "DT",
+                 "scene": f"Assets/Scenes/RevisionEvaluation/{identity}.unity",
+                 "output": str(TASK / "Results" / phase / name / str(targets)),
+                 "report": str(TASK / "Reports" / f"{identity}.json"),
+                 "models": models, "episodes": episodes, "targets": targets, "seed": 42,
+                 "max_steps": 1000, "initial_rtg": {10: 35, 15: 55, 20: 70}[targets],
+                 "timeout_seconds": 43200 if episodes == 50 else 1800}
+        write(TASK / "Jobs" / f"{identity}.json", value)
+
+    for phase in ("smoke", "repeat"):
+        job(phase, "ppo", [ppo])
+        job(phase, "dt", [dt[0]])
+        job(phase, "bc", [bc[0]])
+    for targets in (10, 15, 20):
+        job("full", "ppo", [ppo], targets, 50)
+        job("full", "transformers", [*dt, *bc], targets, 50)
+    print(f"Verified {len(expected)} handoff files; recorded 19 model hashes/contracts; prepared 12 jobs.")
+
+
+if __name__ == "__main__":
+    main()

Upload/01_Source_Code/Python_Evaluation/RevisionEvaluation_Local_20260910/Tools/progress.py

@@ -0,0 +1,28 @@
+"""Read-only progress snapshot for the long evaluation phase."""
+import json
+from pathlib import Path
+import re
+from datetime import datetime, timezone
+
+task = Path(__file__).resolve().parents[1]
+phase_path = task / "Reports/full-phase.json"
+if phase_path.exists():
+    phase = json.loads(phase_path.read_text())
+    files = list((task / "Results/full").rglob("*.json"))
+    completed = {item["id"] for item in phase["jobs"] if item["passed"]}
+    jobs = [f"full-{kind}-{targets}" for targets in (10, 15, 20) for kind in ("ppo", "transformers")]
+    current = next((job for job in jobs if job not in completed), None)
+    log_path = task / "Logs" / f"{current}.log"
+    details = {}
+    if log_path.exists():
+        text = log_path.read_text(encoding="utf-8", errors="replace")
+        models = re.findall(r"\[Evaluation\] ([^\r\n]+): (?:DT, return-conditioned|BC, RTG always zero)", text)
+        episodes = re.findall(r"Episode (\d+)/50 Finished", text)
+        details = {"model": models[-1] if models else "PPO/startup",
+                   "finished_episodes_in_job": len(episodes),
+                   "last_episode": int(episodes[-1]) if episodes else 0,
+                   "errors": re.findall(r"(?:\w+Exception:|error CS\d+|\[Evaluation\] Aborted)[^\r\n]*", text)[-3:]}
+    elapsed = (datetime.now(timezone.utc) - datetime.fromisoformat(phase["started_utc"])).total_seconds()
+    print(json.dumps({"status": phase["status"], "result_files": len(files), "expected_files": 57,
+                      "completed_episodes_in_saved_files": 50 * len(files), "current_job": current,
+                      "elapsed_minutes": round(elapsed / 60, 1), **details}, ensure_ascii=False))

Upload/01_Source_Code/Python_Evaluation/RevisionEvaluation_Local_20260910/Tools/run_phase.py

@@ -0,0 +1,93 @@
+"""Run explicit Unity jobs sequentially; retain all logs and fail closed on errors."""
+import argparse
+import json
+from pathlib import Path
+import subprocess
+import sys
+from datetime import datetime, timezone
+
+TASK = Path(__file__).resolve().parents[1]
+SOURCE = TASK.parents[1]
+VALIDATOR = SOURCE / "Document/ShootingGame_IDE_Handoff/evaluation_code/Tools/validate_evaluation.py"
+
+
+def load(path):
+    return json.loads(path.read_text(encoding="utf-8-sig"))
+
+
+def save(path, value):
+    path.write_text(json.dumps(value, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+def validate(phase, episodes, models, targets):
+    command = [sys.executable, str(VALIDATOR), str(TASK / "Results" / phase),
+               "--expected-episodes", str(episodes), "--expected-models", str(models),
+               "--expected-targets", *map(str, targets)]
+    result = subprocess.run(command, capture_output=True, text=True, encoding="utf-8", errors="replace")
+    (TASK / "Logs" / f"{phase}-validation.log").write_text(result.stdout + result.stderr, encoding="utf-8")
+    print(result.stdout + result.stderr, flush=True)
+    return result.returncode == 0
+
+
+def repeat_check():
+    def collect(phase):
+        return {d["evaluation"]["model_name"]: d for p in (TASK / "Results" / phase).rglob("*.json")
+                if "evaluation" in (d := load(p))}
+    first, second = collect("smoke"), collect("repeat")
+    assert len(first) == len(second) == 3 and first.keys() == second.keys()
+    rows = []
+    for model, a in first.items():
+        b = second[model]
+        state_match = all(a["evaluation"][k] == b["evaluation"][k]
+                          for k in ("initial_states", "initial_state_sha256", "episode_seeds"))
+        row = {"model": model, "policy": a["evaluation"]["policy_type"], "initial_state_match": state_match,
+               "wins_match": a["all_wins"] == b["all_wins"], "steps_match": a["all_steps"] == b["all_steps"],
+               "rewards_match": a["all_rewards"] == b["all_rewards"],
+               "first_steps": a["all_steps"], "repeat_steps": b["all_steps"]}
+        rows.append(row)
+    passed = all(r["initial_state_match"] for r in rows)
+    save(TASK / "Reports/reproducibility.json", {"initial_states_passed": passed, "models": rows})
+    return passed
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("phase", choices=["smoke", "repeat", "full"])
+    args = parser.parse_args()
+    phase = args.phase
+    assert load(TASK / "Reports/unity-verification.json")["status"] == "passed", "Unity verification is required."
+    if phase == "repeat":
+        assert load(TASK / "Reports/smoke-phase.json")["status"] == "passed"
+    if phase == "full":
+        assert load(TASK / "Reports/repeat-phase.json")["status"] == "passed"
+        assert load(TASK / "Reports/reproducibility.json")["initial_states_passed"]
+    names = ([f"{phase}-{kind}-10" for kind in ("ppo", "dt", "bc")] if phase != "full" else
+             [f"full-{kind}-{count}" for count in (10, 15, 20) for kind in ("ppo", "transformers")])
+    summary = {"phase": phase, "status": "running", "started_utc": datetime.now(timezone.utc).isoformat(), "jobs": []}
+    report_path = TASK / "Reports" / f"{phase}-phase.json"
+    save(report_path, summary)
+    for name in names:
+        command = ["powershell.exe", "-NoProfile", "-File", str(TASK / "Tools/Run-Unity.ps1"),
+                   "-Mode", "Run", "-JobPath", str(TASK / "Jobs" / f"{name}.json"), "-RunName", name]
+        print(f"Starting {name}", flush=True)
+        result = subprocess.run(command)
+        job_report = TASK / "Reports" / f"{name}.json"
+        passed = result.returncode == 0 and job_report.exists() and load(job_report)["status"] == "passed"
+        summary["jobs"].append({"id": name, "process_exit": result.returncode, "passed": passed})
+        save(report_path, summary)
+        if not passed:
+            summary["status"] = "failed"
+            save(report_path, summary)
+            raise SystemExit(1)
+    passed = validate(phase, 50 if phase == "full" else 2, 19 if phase == "full" else 3,
+                      [10, 15, 20] if phase == "full" else [10])
+    if phase == "repeat" and passed:
+        passed = repeat_check()
+    summary["status"] = "passed" if passed else "failed"
+    summary["finished_utc"] = datetime.now(timezone.utc).isoformat()
+    save(report_path, summary)
+    raise SystemExit(0 if passed else 1)
+
+
+if __name__ == "__main__":
+    main()

Upload/01_Source_Code/Python_Evaluation/RevisionEvaluation_Local_20260910/Tools/summarize_results.py

@@ -0,0 +1,58 @@
+"""Report evaluation artifacts without editing the manuscript or combining old logs."""
+import hashlib
+import json
+from pathlib import Path
+import statistics
+
+TASK = Path(__file__).resolve().parents[1]
+SOURCE = TASK.parents[1]
+
+
+def digest(path):
+    with path.open("rb") as stream:
+        return hashlib.file_digest(stream, "sha256").hexdigest()
+
+
+def main():
+    result = {}
+    for phase in ("smoke", "repeat", "full"):
+        rows = []
+        for path in (TASK / "Results" / phase).rglob("*.json"):
+            data = json.loads(path.read_text(encoding="utf-8"))
+            if "evaluation" not in data:
+                continue
+            meta = data["evaluation"]
+            rows.append({"targets": meta["target_count"], "model": meta["model_name"], "policy": meta["policy_type"],
+                         "episodes": data["episodes"], "successes": sum(data["all_wins"]),
+                         "success_percent": data["win_rate"], "mean_steps": statistics.mean(data["all_steps"]),
+                         "mean_reward": statistics.mean(data["all_rewards"]),
+                         "sample_sd_reward": statistics.stdev(data["all_rewards"]) if data["episodes"] > 1 else None,
+                         "mean_episode_request_accuracy": statistics.mean(data["all_accuracies"]),
+                         "mean_episode_actual_accuracy": statistics.mean(data["all_actual_firing_accuracies"]),
+                         "result": str(path.relative_to(TASK)), "sha256": digest(path)})
+        result[phase] = sorted(rows, key=lambda row: (row["targets"], row["model"]))
+    (TASK / "Reports/results-summary.json").write_text(json.dumps(result, indent=2), encoding="utf-8")
+    lines = ["# 로컬 Unity 평가 결과", "", "과거 결과 및 원고 수치는 포함하지 않는다. 각 단계의 통과 여부는 Reports/*-phase.json을 확인한다.", ""]
+    for phase, rows in result.items():
+        lines += [f"## {phase}", "", f"완료 결과 파일 {len(rows)}개, 에피소드 {sum(row['episodes'] for row in rows)}개.", "",
+                  "| 표적 | 모델 | 성공/평가 | 평균 action 수 | 평균 보상 | 보상 표본 SD |",
+                  "|---:|---|---:|---:|---:|---:|"]
+        for row in rows:
+            lines.append(f"| {row['targets']} | {row['model']} | {row['successes']}/{row['episodes']} | "
+                         f"{row['mean_steps']:.2f} | {row['mean_reward']:.4f} | {row['sample_sd_reward']:.4f} |")
+        lines.append("")
+    lines += ["성공률의 통계적 비교, 다중비교 보정, 신뢰구간은 이 요약에서 수행하지 않았다.",
+              "2회 확인 실행은 성능 결론용 표본이 아니다. 초기 확인·반복 확인·본 평가를 합산하지 않는다."]
+    (TASK / "RESULTS_KO.md").write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    original = json.loads((TASK / "Reports/original-project-sha256.json").read_text(encoding="utf-8-sig"))
+    changed = [item["path"] for item in original if not (SOURCE / item["path"]).exists()
+               or digest(SOURCE / item["path"]) != item["sha256"]]
+    (TASK / "Reports/original-preservation.json").write_text(
+        json.dumps({"checked_files": len(original), "changed_or_missing": changed}, indent=2), encoding="utf-8")
+    print({phase: {"files": len(rows), "episodes": sum(r["episodes"] for r in rows)} for phase, rows in result.items()})
+    print("Original file changes:", changed)
+
+
+if __name__ == "__main__":
+    main()

Upload/01_Source_Code/Python_Evaluation/ShootingGame_IDE_Handoff/evaluation_code/Tests/test_validate_evaluation.py

@@ -0,0 +1,78 @@
+import copy
+import importlib.util
+import json
+from pathlib import Path
+import tempfile
+import unittest
+spec=importlib.util.spec_from_file_location('validator',Path(__file__).parents[1]/'Tools/validate_evaluation.py')
+v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v)
+
+def sample(model='E1_BC_100'):
+    return dict(episodes=2,win_rate=50,avg_reward=3.5,reward_std=1.5,avg_steps=525,
+        accuracy=14,smoothness=205/1050,actual_firing_accuracy=100,
+        all_wins=[1,0],all_steps=[50,1000],all_rewards=[5,2],all_smoothness=[0.1,0.2],
+        all_accuracies=[20,8],all_actual_firing_accuracies=[100,100],
+        evaluation=dict(protocol_version=v.PROTOCOL,model_name=model,target_count=10,episodes_requested=2,
+            master_seed=42,episode_seeds=[42,43],initial_states=[dict(episode=i+1,seed=42+i,targets=[{}]*10) for i in range(2)],
+            initial_state_sha256=['a'*64,'b'*64],episode_action_steps=[50,1000],episode_shots_fired=[50,50],
+            episode_shots_hit=[10,4],episode_raycasts=[10,4],max_action_steps=1000,policy_type='BC',bc_zero_rtg=True,
+            initial_rtg=0,max_abs_rtg_input=[0,0],episode_terminal_rtg=[0,0],input_traces=[],
+            reward_protocol=v.REWARD,sequence_protocol=v.SEQUENCE,accuracy_protocol=v.ACCURACY,
+            action_history_protocol='raw-continuous-and-actual-fire-v1',fixed_delta_time=0.02,rotation_speed=100,
+            shoot_distance=50,step_penalty=-0.001,unity_version='test-version',enemy_layer_mask=64,queries_hit_triggers=True))
+
+class LogChecks(unittest.TestCase):
+    def run_case(self,data,**kwargs):
+        with tempfile.TemporaryDirectory() as tmp:
+            for i,d in enumerate(data):Path(tmp,f'{i}.json').write_text(json.dumps(d))
+            return v.validate(tmp,2,**kwargs)
+    def check_change(self,change,keyword):
+        a=sample();change(a)
+        errors=self.run_case([a])[0]
+        self.assertTrue(any(keyword in e for e in errors),errors)
+    def test_accepts_matching_episodes(self):
+        self.assertEqual(self.run_case([sample(),sample('E2_BC_100')])[0],[])
+    def test_seed_schedule(self):
+        self.check_change(lambda a:a['evaluation'].update(episode_seeds=[42,42]),'seed schedule')
+    def test_environment_mismatch(self):
+        a=sample('E2_BC_100');a['evaluation']['initial_states'][1]['targets'][0]={'position':[1,2,3]}
+        self.assertTrue(any('initial_states' in e for e in self.run_case([sample(),a])[0]))
+    def test_bc_input_drift(self):
+        self.check_change(lambda a:a['evaluation'].update(max_abs_rtg_input=[0,0.001]),'BC RTG')
+    def test_bc_terminal_drift(self):
+        self.check_change(lambda a:a['evaluation'].update(episode_terminal_rtg=[0,-2]),'BC RTG')
+    def test_timeout_overrun(self):
+        self.check_change(lambda a:a.update(all_steps=[50,1001]),'step limit')
+    def test_early_failed_episode(self):
+        self.check_change(lambda a:a.update(all_steps=[50,999]),'before timeout')
+    def test_old_logs(self):
+        self.check_change(lambda a:a.pop('evaluation'),'protocol')
+    def test_duplicates(self):
+        self.assertTrue(any('duplicate' in e for e in self.run_case([sample(),sample()])[0]))
+    def test_reward_mismatch_is_error(self):
+        self.check_change(lambda a:a['evaluation'].update(reward_protocol='old'),'reward protocol')
+    def test_missing_target_condition(self):
+        self.assertTrue(any('target conditions' in e for e in self.run_case([sample()],expected_targets=[10,15,20])[0]))
+    def test_wrong_accuracy_denominator(self):
+        self.check_change(lambda a:a.update(all_accuracies=[100,100]),'request accuracy')
+    def test_impossible_raycast_count(self):
+        self.check_change(lambda a:a['evaluation'].update(episode_raycasts=[5,4]),'counts invalid')
+    def test_rtg_includes_terminal_bonus(self):
+        a=sample();a['evaluation'].update(policy_type='DT',initial_rtg=35,bc_zero_rtg=False,max_abs_rtg_input=[35,35],episode_terminal_rtg=[30,33])
+        self.assertEqual(self.run_case([a])[0],[])
+        a['evaluation']['episode_terminal_rtg'][0]=32
+        self.assertTrue(any('terminal RTG' in e for e in self.run_case([a])[0]))
+    def test_summary_reward(self):
+        self.check_change(lambda a:a.update(avg_reward=99),'avg_reward')
+    def test_nan_input(self):
+        self.check_change(lambda a:a.update(all_rewards=[float('nan'),2]),'all_rewards')
+    def test_null_metadata_array(self):
+        self.check_change(lambda a:a['evaluation'].update(episode_shots_hit=None),'episode_shots_hit')
+    def test_sensitivity_separation(self):
+        self.check_change(lambda a:a['evaluation'].update(rtg_sensitivity=True),'sensitivity')
+    def test_trace_timestep_rollover(self):
+        a=sample();a['evaluation']['input_traces']=[dict(timestep=32,valid_length=32,timesteps=list(range(32)),
+            observations=[0]*288,actions=[0]*96,returns_to_go=[0]*32)]
+        self.assertTrue(any('absolute timesteps' in e for e in self.run_case([a])[0]))
+
+if __name__=='__main__':unittest.main()

Upload/01_Source_Code/Python_Evaluation/ShootingGame_IDE_Handoff/evaluation_code/Tools/validate_evaluation.py

@@ -0,0 +1,180 @@
+"""Validate aligned-evaluation-v2.1 JSON logs. Python 3 standard library only; never edits logs."""
+import argparse
+from collections import defaultdict
+import json
+import math
+from pathlib import Path
+
+PROTOCOL = 'aligned-evaluation-v2.1'
+REWARD = 'ShootingAgent-shaped-angle-v1'
+SEQUENCE = 'dataset-shifted-action-right-pad32-v2'
+ACCURACY = 'hits-per-fire-request-percent-v1'
+
+def number(v):
+    return isinstance(v, (int, float)) and not isinstance(v, bool) and math.isfinite(v)
+
+def close(a, b):
+    return number(a) and math.isclose(a, b, rel_tol=2e-5, abs_tol=2e-4)
+
+def validate(root, expected_episodes=50, expected_models=None, expected_targets=None, allow_rtg_sensitivity=False):
+    errors, warnings, results = [], [], []
+    for path in sorted(Path(root).rglob('*.json')):
+        try:
+            data = json.loads(path.read_text(encoding='utf-8-sig'))
+        except (ValueError, OSError) as exc:
+            errors.append(f'{path}: unreadable JSON: {exc}'); continue
+        if not isinstance(data, dict) or 'all_wins' not in data:
+            continue
+        meta = data.get('evaluation')
+        if not isinstance(meta, dict) or meta.get('protocol_version') != PROTOCOL:
+            errors.append(f'{path}: missing/current protocol metadata; do not mix old logs'); continue
+        label = f'{meta.get("target_count")}/{meta.get("model_name")}'
+        def fail(message): errors.append(f'{label}: {message}')
+        n = data.get('episodes')
+        if type(n) is not int or n < 1:
+            fail('invalid episode count'); continue
+        if n != expected_episodes or meta.get('episodes_requested') != n:
+            fail(f'expected {expected_episodes} episodes, got {n}')
+        policy = meta.get('policy_type')
+        if policy not in ('PPO', 'DT', 'BC'): fail('unknown policy type')
+        if type(meta.get('target_count')) is not int or meta['target_count'] <= 0:
+            fail('invalid target count'); continue
+        if not isinstance(meta.get('model_name'), str) or not meta['model_name']:
+            fail('missing model name')
+        if meta.get('reward_protocol') != REWARD: fail('reward protocol differs from common training-based reward')
+        if meta.get('accuracy_protocol') != ACCURACY: fail('accuracy protocol mismatch')
+        expected_sequence = 'PPO' if policy == 'PPO' else SEQUENCE
+        if meta.get('sequence_protocol') != expected_sequence: fail('sequence protocol mismatch')
+        expected_history = 'PPO' if policy == 'PPO' else 'raw-continuous-and-actual-fire-v1'
+        if meta.get('action_history_protocol') != expected_history: fail('action history protocol mismatch')
+        if meta.get('rtg_sensitivity') and not allow_rtg_sensitivity:
+            fail('RTG sensitivity run mixed with main evaluation; use a separate folder or --allow-rtg-sensitivity')
+        for key in ['fixed_delta_time', 'rotation_speed', 'shoot_distance']:
+            if not number(meta.get(key)) or meta[key] <= 0: fail(f'invalid setting {key}')
+        if not number(meta.get('step_penalty')): fail('invalid step penalty')
+        if not isinstance(meta.get('unity_version'), str) or not meta['unity_version']: fail('missing Unity version')
+        if type(meta.get('queries_hit_triggers')) is not bool: fail('missing physics trigger setting')
+        if type(meta.get('enemy_layer_mask')) is not int: fail('missing enemy layer mask')
+        limit = meta.get('max_action_steps')
+        if type(limit) is not int or limit < 1: fail('invalid step limit'); limit = 0
+        elif policy in ('DT', 'BC') and limit > 4096: fail('timestep capacity exceeded')
+
+        numeric_arrays = ['all_wins', 'all_rewards', 'all_steps', 'all_smoothness',
+                          'all_accuracies', 'all_actual_firing_accuracies']
+        valid_arrays = True
+        for key in numeric_arrays:
+            values = data.get(key)
+            if not isinstance(values, list) or len(values) != n or not all(number(v) for v in values):
+                fail(f'{key} invalid/length mismatch'); valid_arrays = False
+        counts_valid = True
+        for key in ['episode_action_steps', 'episode_shots_fired', 'episode_shots_hit', 'episode_raycasts']:
+            values = meta.get(key)
+            if not isinstance(values, list) or len(values) != n or not all(type(v) is int and v >= 0 for v in values):
+                fail(f'{key} invalid/length mismatch'); counts_valid = False
+        for key in ['episode_seeds', 'initial_states', 'initial_state_sha256']:
+            if not isinstance(meta.get(key), list) or len(meta[key]) != n: fail(f'{key} length mismatch')
+        master = meta.get('master_seed')
+        if type(master) is not int or meta.get('episode_seeds') != list(range(master, master + n)):
+            fail('seed schedule mismatch')
+        states = meta.get('initial_states')
+        if isinstance(states, list):
+            for i, state in enumerate(states):
+                if not isinstance(state, dict) or state.get('episode') != i + 1 or type(master) is not int or state.get('seed') != master + i:
+                    fail('initial_states episode/seed mismatch'); break
+                if not isinstance(state.get('targets'), list) or len(state['targets']) != meta['target_count']:
+                    fail('initial_states target count mismatch'); break
+        hashes = meta.get('initial_state_sha256')
+        if isinstance(hashes, list) and any(not isinstance(v, str) or len(v) != 64 or any(c not in '0123456789abcdef' for c in v) for v in hashes):
+            fail('invalid initial state hash')
+        if valid_arrays:
+            wins, steps, rewards = (data[k] for k in ('all_wins', 'all_steps', 'all_rewards'))
+            if not all(type(v) is int and v in (0, 1) for v in wins): fail('non-binary wins')
+            if not close(data.get('win_rate'), 100 * sum(wins) / n): fail('win_rate inconsistent')
+            if meta.get('episode_action_steps') != steps: fail('action counts differ from all_steps')
+            if any(type(v) is not int or not 1 <= v <= limit for v in steps): fail('step limit violated')
+            if any(w == 0 and step != limit for w, step in zip(wins, steps)): fail('failed episode ended before timeout')
+            if any(not 0 <= v <= 100 for k in ['all_accuracies', 'all_actual_firing_accuracies'] for v in data[k]): fail('accuracy outside 0-100')
+            if any(v < 0 for v in data['all_smoothness']): fail('negative smoothness')
+            mean = sum(rewards) / n
+            if not close(data.get('avg_reward'), mean): fail('avg_reward inconsistent')
+            if not close(data.get('avg_steps'), sum(steps) / n): fail('avg_steps inconsistent')
+            if not close(data.get('reward_std'), math.sqrt(sum((v-mean)**2 for v in rewards) / n)): fail('reward_std inconsistent with population SD')
+            if not close(data.get('smoothness'), sum(a*b for a,b in zip(data['all_smoothness'],steps))/max(1,sum(steps))):
+                fail('smoothness summary inconsistent with step-weighted aggregation')
+            if counts_valid:
+                requests, hits, casts = (meta[k] for k in ['episode_shots_fired','episode_shots_hit','episode_raycasts'])
+                for i, (req, hit, cast, step) in enumerate(zip(requests,hits,casts,steps)):
+                    if not 0 <= hit <= cast <= req <= step: fail(f'episode {i+1}: hit/raycast/request counts invalid')
+                    if hit > meta['target_count'] or (wins[i] == 1) != (hit == meta['target_count']): fail(f'episode {i+1}: hits inconsistent with success')
+                    if not close(data['all_accuracies'][i], 100*hit/req if req else 0): fail('per-episode request accuracy inconsistent')
+                    if not close(data['all_actual_firing_accuracies'][i], 100*hit/cast if cast else 0): fail('per-episode actual firing accuracy inconsistent')
+                if not close(data.get('accuracy'), 100*sum(hits)/sum(requests) if sum(requests) else 0): fail('accuracy summary inconsistent')
+                if not close(data.get('actual_firing_accuracy'), 100*sum(hits)/sum(casts) if sum(casts) else 0): fail('actual firing accuracy summary inconsistent')
+        if policy in ('BC', 'DT'):
+            values = meta.get('max_abs_rtg_input')
+            terminal = meta.get('episode_terminal_rtg')
+            initial = meta.get('initial_rtg')
+            rtg_valid = (number(initial) and isinstance(values,list) and len(values)==n and all(number(v) and v>=0 for v in values)
+                         and isinstance(terminal,list) and len(terminal)==n and all(number(v) for v in terminal))
+            if not rtg_valid: fail('RTG diagnostics invalid')
+            elif policy == 'BC':
+                if meta.get('bc_zero_rtg') is not True or initial != 0 or any(v != 0 for v in values + terminal): fail('BC RTG was not always zero')
+            else:
+                if meta.get('bc_zero_rtg') is not False: fail('DT incorrectly marked zero-RTG')
+                if valid_arrays and any(not math.isclose(t,initial-r,rel_tol=2e-4,abs_tol=0.02) for t,r in zip(terminal,data['all_rewards'])):
+                    fail('terminal RTG does not include the full episode reward')
+            traces = meta.get('input_traces', [])
+            if not isinstance(traces, list):
+                fail('invalid input_traces'); traces = []
+            for trace in traces:
+                if not isinstance(trace,dict): fail('invalid input trace'); continue
+                t, valid = trace.get('timestep'), trace.get('valid_length')
+                if type(t) is not int or t < 0 or valid != min(t+1,32): fail('trace valid length mismatch'); continue
+                expected = list(range(max(0,t-31), t+1)) + [0]*(32-valid)
+                if trace.get('timesteps') != expected: fail('trace absolute timesteps mismatch')
+                for key,dim in [('observations',9),('actions',3),('returns_to_go',1)]:
+                    a = trace.get(key)
+                    if not isinstance(a,list) or len(a)!=32*dim or not all(number(v) for v in a): fail(f'trace {key} invalid'); continue
+                    if any(v!=0 for v in a[valid*dim:]): fail('trace right padding is not zero')
+                    if key=='actions' and any(v not in (0,1) for v in a[2:valid*3:3]): fail('trace fire history is not binary')
+                    if key=='returns_to_go' and policy=='BC' and any(v!=0 for v in a): fail('BC RTG trace drift')
+        results.append((label,path,data,meta))
+
+    if not results: errors.append('No evaluation results found')
+    by_target = defaultdict(list)
+    for row in results: by_target[row[3]['target_count']].append(row)
+    if expected_targets is not None and set(by_target) != set(expected_targets):
+        errors.append(f'Expected target conditions {sorted(expected_targets)}, found {sorted(by_target)}')
+    for target, rows in by_target.items():
+        identities = [(r[3].get('model_name'),r[3].get('initial_rtg'),r[3].get('policy_type')) for r in rows]
+        if len(set(identities)) != len(identities): errors.append(f'{target}: duplicate model/RTG runs; select one run per comparison')
+        models = {r[3].get('model_name') for r in rows}
+        if not allow_rtg_sensitivity and len(models) != len(rows): errors.append(f'{target}: more than one run for a model')
+        if expected_models is not None and len(models) != expected_models: errors.append(f'{target}: expected {expected_models} distinct models, got {len(models)}')
+        baseline = rows[0][3]
+        for label,path,data,meta in rows[1:]:
+            for key in ['episode_seeds','initial_states','initial_state_sha256','fixed_delta_time','max_action_steps',
+                        'rotation_speed','shoot_distance','step_penalty','enemy_layer_mask','unity_version','queries_hit_triggers',
+                        'reward_protocol','accuracy_protocol']:
+                if meta.get(key) != baseline.get(key): errors.append(f'{label}: paired condition mismatch: {key}')
+        if not allow_rtg_sensitivity:
+            rtgs = {r[3].get('initial_rtg') for r in rows if r[3].get('policy_type') == 'DT'}
+            if len(rtgs)>1: errors.append(f'{target}: DT models have different initial RTGs')
+    return errors,warnings,results
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('root',type=Path)
+    p.add_argument('--expected-episodes',type=int,default=50)
+    p.add_argument('--expected-models',type=int)
+    p.add_argument('--expected-targets',type=int,nargs='+')
+    p.add_argument('--allow-rtg-sensitivity',action='store_true')
+    args=p.parse_args()
+    errors,warnings,rows=validate(args.root,args.expected_episodes,args.expected_models,args.expected_targets,args.allow_rtg_sensitivity)
+    for m in errors: print('ERROR:',m)
+    for m in warnings: print('WARNING:',m)
+    print(f'Checked {len(rows)} result files; {len(errors)} errors.')
+    if not errors: print('Protocol/seed/initial-state/metric checks passed. Model validity and statistical assumptions require separate assessment.')
+    raise SystemExit(1 if errors else 0)
+
+if __name__=='__main__': main()

Upload/01_Source_Code/Python_Evaluation/ShootingGame_IDE_Handoff/evaluation_code/Tools/verify_model_pair.py

@@ -0,0 +1,71 @@
+"""Generate reproducible Unity buffer/model fixtures from the supplied Python dataset and model.
+Requires numpy, torch, onnx, onnxruntime. No training or checkpoint modification.
+"""
+import argparse
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+
+def load_module(path,name):
+    spec=importlib.util.spec_from_file_location(name,path)
+    module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module)
+    return module
+
+def main():
+    import numpy as np
+    import torch
+    import onnx
+    import onnxruntime as ort
+    p=argparse.ArgumentParser(description=__doc__)
+    for name in ['model-py','dataset-py','pth','onnx','output']:p.add_argument('--'+name,type=Path,required=True)
+    a=p.parse_args();a.output.mkdir(parents=True,exist_ok=True)
+    torch.set_num_threads(2)
+    model_module=load_module(a.model_py,'verified_model')
+    dataset_module=load_module(a.dataset_py,'verified_dataset')
+    model=model_module.DecisionTransformer(9,3,hidden=256,n_layers=4,n_heads=4,max_len=4096)
+    state=torch.load(a.pth,map_location='cpu',weights_only=True)
+    model.load_state_dict(state,strict=True);model.eval()
+    graph=onnx.load(a.onnx);onnx.checker.check_model(graph,full_check=True)
+    options=ort.SessionOptions();options.intra_op_num_threads=2;options.inter_op_num_threads=1
+    session=ort.InferenceSession(str(a.onnx),sess_options=options,providers=['CPUExecutionProvider'])
+    rng=np.random.default_rng(20260910)
+    observations=rng.uniform(-1,1,(1000,9)).astype(np.float32)
+    actions=rng.uniform(-1,1,(1000,3)).astype(np.float32);actions[:,2]=(actions[:,2]>0).astype(np.float32)
+    rewards=rng.uniform(-0.01,0.08,(1000,1)).astype(np.float32)
+    ds=dataset_module.TrajectoryDataset.__new__(dataset_module.TrajectoryDataset)
+    rows=[dict(obs=torch.from_numpy(observations[i]),act=torch.from_numpy(actions[i]),
+               rew=torch.from_numpy(rewards[i]),done=torch.tensor([float(i==999)])) for i in range(1000)]
+    ep=ds._process_episode(rows)
+    fixtures=dict(model=a.onnx.stem,onnx_sha256=hashlib.sha256(a.onnx.read_bytes()).hexdigest(),seq_len=32,
+        steps=[dict(observations=observations[i].tolist(),recorded_action=actions[i].tolist(),rtg=float(ep['rtg'][i].item())) for i in range(1000)],cases=[])
+    report=dict(strict_state_load=True,onnx_full_check=True,checkpoint_tensors=len(state),
+        model_sha256=fixtures['onnx_sha256'],source_sha256={p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in [a.model_py,a.dataset_py,a.pth]},
+        versions=dict(torch=torch.__version__,onnx=onnx.__version__,onnxruntime=ort.__version__),tests=[])
+    for is_bc in [False,True]:
+        for t in [0,1,7,30,31,32,33,100,999]:
+            start=max(0,t-31);n=t-start+1
+            live=dict(observations=ep['obs'][start:t+1].numpy()[None,:],
+                actions=ep['shifted_act'][start:t+1].numpy()[None,:],
+                returns_to_go=np.zeros((1,n,1),np.float32) if is_bc else ep['rtg'][start:t+1].numpy()[None,:],
+                timesteps=ep['timesteps'][start:t+1].numpy()[None,:].astype(np.int32))
+            with torch.inference_mode():
+                expected=model(torch.from_numpy(live['observations']),torch.from_numpy(live['actions']),
+                    torch.from_numpy(live['returns_to_go']),torch.from_numpy(live['timesteps'].astype(np.int64))).numpy()[0,-1]
+            padded={k:np.zeros((1,32)+x.shape[2:],dtype=x.dtype) for k,x in live.items()}
+            for k,x in live.items():padded[k][:,:n]=x
+            actual=session.run(None,padded)[0][0,n-1]
+            diff=float(np.max(np.abs(actual-expected)))
+            passed=bool(np.allclose(actual,expected,atol=1e-4,rtol=1e-4))
+            report['tests'].append(dict(timestep=t,is_bc=is_bc,valid_length=n,max_abs_error=diff,passed=passed))
+            assert passed,(t,is_bc,diff)
+            fixtures['cases'].append(dict(timestep=t,is_bc=is_bc,valid_length=n,
+                expected_action=expected.tolist(),**{k:v.reshape(-1).tolist() for k,v in padded.items()}))
+    report['all_passed']=all(t['passed'] for t in report['tests'])
+    report['maximum_absolute_error']=max(t['max_abs_error'] for t in report['tests'])
+    (a.output/'E_1_DT_C_5_sequence_fixtures.json').write_text(json.dumps(fixtures,indent=2))
+    (a.output/'model_verification.json').write_text(json.dumps(report,indent=2))
+    print(json.dumps({k:report[k] for k in ['all_passed','maximum_absolute_error','checkpoint_tensors']}))
+    print('Passed',len(report['tests']),'dataset / PyTorch / fixed-32 ONNX cases. Unity execution is a separate test.')
+
+if __name__=='__main__':main()

Upload/01_Source_Code/Python_Training/dataset_dt.py

@@ -0,0 +1,193 @@
+# dataset_dt.py
+import json
+import torch
+from torch.utils.data import Dataset
+import glob
+import os
+import pickle
+import numpy as np
+
+class TrajectoryDataset(Dataset):
+    def __init__(self, log_dir, seq_len=32, specific_file=None):
+        self.seq_len = seq_len
+        self.raw_data = [] 
+        
+        # NEW APPROACH: Load data into EPISODES.
+        
+        raw_rows = []
+
+        if specific_file:
+            print(f"[INFO] Loading specific file: {specific_file}...")
+            try:
+                with open(specific_file, "rb") as f:
+                    raw_rows = pickle.load(f)
+                print(f"[INFO] Loaded {len(raw_rows)} steps from {specific_file}.")
+            except (EOFError, pickle.UnpicklingError) as e:
+                print(f"[ERROR] Failed to load {specific_file}: {e}")
+                raw_rows = []
+        else:
+             # Check for split pickle files first (Memory Efficient Load)
+            split_files = sorted(glob.glob(os.path.join(log_dir, "trajectory_data_part_*.pkl")))
+            if not split_files:
+                 split_files = sorted(glob.glob("trajectory_data_part_*.pkl"))
+
+            if split_files:
+                raise RuntimeError(
+                    f"[ERROR] Found {len(split_files)} split files but 'specific_file' was not provided.\n"
+                    "Cannot load all split files at once due to memory constraints.\n"
+                    "Please use 'train_sequential.py' to train sequentially on chunks."
+                )
+            else:
+                 # Fallback to single pickle or JSON
+                pickle_file = "trajectory_data.pkl"
+                if os.path.exists(pickle_file):
+                    print(f"[INFO] Loading data from {pickle_file}...")
+                    try:
+                        with open(pickle_file, "rb") as f:
+                            raw_rows = pickle.load(f)
+                        print(f"[INFO] Loaded {len(raw_rows)} steps from pickle.")
+                    except Exception as e:
+                        print(f"[WARNING] Pickle corrupted: {e}")
+                        raw_rows = []
+                
+        if not raw_rows:
+            json_files = sorted(glob.glob(os.path.join(log_dir, "*.json")))
+            if json_files: 
+                print(f"[INFO] Loading {len(json_files)} JSON files...")
+                for jf in json_files:
+                    try:
+                        with open(jf, 'r') as f:
+                            data = json.load(f)
+                            rows = data.get("data", [])
+                            # Normalize JSON rows to lists if needed
+                            for r in rows:
+                                vals = r["values"] if isinstance(r, dict) else r
+                                if isinstance(vals, list) and len(vals) == 14:
+                                    raw_rows.append(vals)
+                    except: pass
+
+        # Process raw_rows into Episodes => Steps
+        # We need to reconstruct episodes to calculate RTG correctly.
+        self.episodes = [] 
+        current_episode = []
+        
+        for row in raw_rows:
+            # row can be a dict (from convert_added_json_to_pickle) OR a list (legacy raw values)
+            
+            if isinstance(row, dict):
+                # Format: {'obs': tensor, 'act': tensor, 'rew': tensor, 'done': tensor}
+                obs = row['obs']
+                act = row['act'] 
+                rew = row['rew']
+                done = row['done']
+                
+                # Ensure they are tensors
+                if not isinstance(obs, torch.Tensor): obs = torch.tensor(obs, dtype=torch.float32)
+                if not isinstance(act, torch.Tensor): act = torch.tensor(act, dtype=torch.float32)
+                if not isinstance(rew, torch.Tensor): rew = torch.tensor(rew, dtype=torch.float32)
+                if not isinstance(done, torch.Tensor): done = torch.tensor(done, dtype=torch.float32)
+                
+            else:
+                # Legacy List format
+                vals = torch.tensor(row, dtype=torch.float32)
+                obs = vals[:9]
+                act_cont = vals[9:11]
+                act_fire = vals[11:12]
+                rew = vals[12:13] 
+                done = vals[13:14]
+                act = torch.cat([act_cont, act_fire])
+            
+            step = {
+                "obs": obs,
+                "act": act,
+                "rew": rew,
+                "done": done
+            }
+            current_episode.append(step)
+            
+            # Check done flag (assuming scalar tensor)
+            if done.item() > 0.5:
+                self.episodes.append(self._process_episode(current_episode))
+                current_episode = []
+                
+        # Handle trailing data
+        if current_episode:
+             self.episodes.append(self._process_episode(current_episode))
+
+        # Flatten for indexing
+        self.indices = []
+        for ep_idx, ep in enumerate(self.episodes):
+            length = len(ep["obs"])
+            for t in range(length):
+                self.indices.append((ep_idx, t))
+
+        print(f"[INFO] Processed {len(self.episodes)} episodes. Total {len(self.indices)} samples.")
+
+    def _process_episode(self, episode_steps):
+        # Calculate RTG for this episode
+        rews = torch.stack([s["rew"] for s in episode_steps]) # (L, 1)
+        
+        # RTG calculation: Cumulative sum from back to front
+        rtg = torch.flip(torch.cumsum(torch.flip(rews, dims=[0]), dim=0), dims=[0])
+        if rtg.dim() == 1:
+            rtg = rtg.unsqueeze(-1) # Ensure (L, 1)
+        
+        # Timesteps
+        timesteps = torch.arange(len(episode_steps), dtype=torch.long)
+        
+        # Stack others
+        obs = torch.stack([s["obs"] for s in episode_steps])
+        acts = torch.stack([s["act"] for s in episode_steps])
+        dones = torch.stack([s["done"] for s in episode_steps])
+        
+        # Create Shifted Actions (a_{t-1}) for input
+        # Prepend zero, remove last
+        first_zero = torch.zeros(1, acts.shape[1])
+        shifted_acts = torch.cat([first_zero, acts[:-1]], dim=0)
+
+        return {
+            "obs": obs,
+            "act": acts,          # Target (a_t)
+            "shifted_act": shifted_acts, # Input (a_{t-1})
+            "rtg": rtg,
+            "timesteps": timesteps,
+            "len": len(episode_steps)
+        }
+
+    def __len__(self):
+        return len(self.indices)
+
+    def __getitem__(self, idx):
+        ep_idx, start_t = self.indices[idx]
+        ep = self.episodes[ep_idx]
+        
+        end_t = start_t + self.seq_len
+        real_end = min(end_t, ep["len"])
+        
+        # Aligned Slicing: All tensors sliced identically [start : end]
+        # Logic: Input(s_t, a_{t-1}) -> Target(a_t)
+        
+        obs = ep["obs"][start_t : real_end]
+        rtg = ep["rtg"][start_t : real_end]
+        time = ep["timesteps"][start_t : real_end]
+        
+        target = ep["act"][start_t : real_end]        # a_t (Target)
+        act = ep["shifted_act"][start_t : real_end]   # a_{t-1} (Input)
+        
+        # Pad if necessary to match seq_len
+        # Pad to full seq_len
+        if obs.shape[0] < self.seq_len:
+             pad = self.seq_len - obs.shape[0]
+             obs = torch.cat([obs, torch.zeros(pad, obs.shape[1])])
+             act = torch.cat([act, torch.zeros(pad, act.shape[1])])
+             target = torch.cat([target, torch.zeros(pad, act.shape[1])])
+             rtg = torch.cat([rtg, torch.zeros(pad, 1)])
+             time = torch.cat([time, torch.zeros(pad, dtype=torch.long)])
+             
+        return {
+            "observations": obs,
+            "actions": act,            # Input a_{t-1}
+            "returns_to_go": rtg,
+            "timesteps": time,
+            "target_actions": target   # Target a_t
+        }

Upload/01_Source_Code/Python_Training/finetuning_ext_RLStep.py

@@ -0,0 +1,215 @@
+import torch
+from torch.utils.data import DataLoader, Subset
+from dataset_dt import TrajectoryDataset
+from model_dt import DecisionTransformer
+import glob
+import os
+import gc
+import time
+import argparse
+import sys
+import re
+
+def finetuning_rl_steps(
+    data_prefix="trajectory_data_part_", 
+    output_model="dt_model_finetuned.pth", 
+    load_model="dt_model_trained.pth",
+    target_rl_steps=1000000,
+    epochs=5,
+    learning_rate=1e-5
+):
+    log_dir = "./logs"
+    seq_len = 32
+    batch_size = 32
+    
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"[INFO] Using device: {device}")
+
+    # 1. Initialize Model Dimensions (Peek Logic)
+    pattern = f"{data_prefix}*.pkl"
+    split_files = sorted(glob.glob(pattern))
+    if not split_files:
+        split_files = sorted(glob.glob(os.path.join(log_dir, pattern)))
+        
+    if not split_files:
+        # Fallback for spelling
+        if "Trajectoy" in data_prefix:
+            fallback = data_prefix.replace("Trajectoy", "Trajectory")
+            split_files = sorted(glob.glob(fallback))
+            
+    if not split_files:
+        print(f"[ERROR] No files found matching prefix: {data_prefix}")
+        return
+
+    print(f"[INFO] Found {len(split_files)} split files matching '{data_prefix}'.")
+    
+    print("[INFO] Peeking at first file for dimensions...")
+    temp_dataset = TrajectoryDataset(log_dir, seq_len=seq_len, specific_file=split_files[0])
+    if len(temp_dataset) > 0:
+        obs_dim = temp_dataset[0]["observations"].shape[-1]
+        act_dim = temp_dataset[0]["actions"].shape[-1]
+    else:
+        obs_dim = 9
+        act_dim = 3
+        
+    del temp_dataset
+    gc.collect()
+    
+    print(f"[INFO] Obs Dim: {obs_dim}, Act Dim: {act_dim}")
+
+    # 2. Model Setup
+    model = DecisionTransformer(
+        obs_dim=obs_dim,
+        act_dim=act_dim,
+        hidden=256,
+        n_layers=4,
+        n_heads=4,
+        max_len=4096 
+    ).to(device)
+
+    # Load Checkpoint
+    if os.path.exists(load_model):
+        print(f"[INFO] Loading checkpoint: {load_model}")
+        try:
+            state_dict = torch.load(load_model, map_location=device)
+            model.load_state_dict(state_dict)
+            print("[INFO] Model loaded successfully.")
+        except Exception as e:
+            print(f"[ERROR] Failed to load checkpoint: {e}")
+            return
+    else:
+        print(f"[WARNING] Checkpoint '{load_model}' not found! Starting FRESH training (Fine-Tuning aborted).")
+        # Depending on user intent, we might want to return here. 
+        # But usually we proceed if user insists, though it's technically Pre-training then.
+
+    print(f"[INFO] Learning rate: {learning_rate}")
+    optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)
+    
+    print(f"[INFO] Starting FINE-TUNING with RL STEP LIMIT: {target_rl_steps} (Pre-loading to Memory)")
+
+    # 3. Pre-load Data Phase
+    loaded_datasets = []
+    total_rl_steps_loaded = 0
+    
+    for i, pkl_file in enumerate(split_files):
+        steps_needed = target_rl_steps - total_rl_steps_loaded
+        if steps_needed <= 0:
+            break
+            
+        print(f"[INFO] Pre-loading chunk {i+1}/{len(split_files)}: {pkl_file}")
+        dataset = TrajectoryDataset(log_dir, seq_len=seq_len, specific_file=pkl_file)
+        dataset_len = len(dataset)
+        
+        if dataset_len == 0:
+            continue
+            
+        if dataset_len > steps_needed:
+            print(f"  [LIMIT] Trimming chunk to {steps_needed} samples.")
+            dataset = Subset(dataset, range(steps_needed))
+            loaded_datasets.append(dataset)
+            total_rl_steps_loaded += steps_needed
+            break
+        else:
+            loaded_datasets.append(dataset)
+            total_rl_steps_loaded += dataset_len
+            
+        print(f"  [PROGRESS] Memory Buffer: {total_rl_steps_loaded} / {target_rl_steps}")
+
+    if not loaded_datasets:
+        print("[ERROR] No data loaded! Check file paths.")
+        return
+
+    # 4. Training Phase (Sequential Chunk Processing)
+    print(f"[INFO] Data Pre-loading Complete. Starting Fine-Tuning on {len(loaded_datasets)} chunks.")
+    
+    global_gradient_steps = 0
+    
+    for epoch in range(epochs):
+        print(f"\n=== Fine-Tuning Epoch {epoch+1}/{epochs} ===")
+        epoch_start_time = time.time()
+        
+        for i, dataset in enumerate(loaded_datasets):
+            loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
+            
+            model.train()
+            chunk_loss = 0.0
+            chunk_steps = 0
+            
+            for batch in loader:
+                states = batch['observations'].to(device)
+                actions = batch['actions'].to(device)
+                returns = batch['returns_to_go'].to(device)
+                timesteps = batch['timesteps'].to(device)
+                
+                # Forward
+                action_preds = model(
+                    obs=states,
+                    act=actions,
+                    rtg=returns,
+                    timesteps=timesteps
+                )
+                
+                # Loss
+                action_target = batch['target_actions'].to(device)
+                loss = torch.mean((action_preds - action_target) ** 2)
+                
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                
+                chunk_loss += loss.item()
+                chunk_steps += 1
+                global_gradient_steps += 1
+                
+                if chunk_steps % 100 == 0:
+                    print(f"  Grad Step {chunk_steps}, Loss: {loss.item():.4f}", end="\r")
+            
+            avg_chunk_loss = chunk_loss / chunk_steps if chunk_steps > 0 else 0
+            print(f"  Chunk {i+1} Finished. Avg Loss: {avg_chunk_loss:.4f}")
+
+        print(f"Epoch {epoch+1} completed in {time.time() - epoch_start_time:.2f}s.")
+        
+        # Save Model per Epoch
+        dir_name, file_name = os.path.split(output_model)
+        epoch_model_path = os.path.join(dir_name, f"E_{epoch+1}_{file_name}")
+        torch.save(model.state_dict(), epoch_model_path)
+        print(f"[INFO] Saved Epoch {epoch+1} Checkpoint to: {epoch_model_path}")
+        
+    print(f"\n[DONE] Fine-Tuning Finished.")
+    print(f"  Total RL Steps Processed (cached): {total_rl_steps_loaded}")
+    print(f"  Total Gradient Steps: {global_gradient_steps}")
+        
+    # Save Final Model
+    torch.save(model.state_dict(), output_model)
+    print(f"[INFO] Saved Final Model to: {output_model}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Fine-Tune Decision Transformer with RL Step Limit")
+    parser.add_argument("--prefix", type=str, default="trajectory_data_part_", help="Prefix of the pickle files to load")
+    parser.add_argument("--output", type=str, default="dt_model_finetuned.pth", help="Output filename")
+    parser.add_argument("--load_model", type=str, required=True, help="Path to pre-trained model checkpoint")
+    parser.add_argument("--target_rl_steps", type=int, default=1000000, help="Total RL steps (samples) to train on")
+    parser.add_argument("--epochs", type=int, default=5, help="Number of epochs")
+    parser.add_argument("--learning_rate", type=float, default=1e-5, help="Learning rate (default: 1e-5)")
+    
+    args = parser.parse_args()
+    
+    target_steps = args.target_steps if args.target_steps > 0 else 1000000
+    
+    print("\n[Configuration]")
+    print(f"  Load Model: {args.load_model}")
+    print(f"  Prefix: {args.prefix}")
+    print(f"  Output: {args.output}")
+    print(f"  Target RL Steps: {target_steps}")
+    print(f"  Epochs: {args.epochs}")
+    print(f"  LR: {args.learning_rate}")
+    print("-" * 30)
+    
+    finetuning_rl_steps(
+        data_prefix=args.prefix, 
+        output_model=args.output, 
+        load_model=args.load_model,
+        target_rl_steps=target_steps,
+        epochs=args.epochs,
+        learning_rate=args.learning_rate
+    )

Upload/01_Source_Code/Python_Training/model_dt.py

@@ -0,0 +1,85 @@
+import torch
+from torch import nn
+import math
+
+class DecisionTransformer(nn.Module):
+    def __init__(self, obs_dim, act_dim, hidden=256, n_layers=4, n_heads=4, max_len=1024):
+        super().__init__()
+        self.hidden = hidden
+        self.n_heads = n_heads
+        self.max_len = max_len
+
+        # 각 입력을 hidden 차원으로 임베딩
+        self.obs_embed = nn.Linear(obs_dim, hidden)
+        self.act_embed = nn.Linear(act_dim, hidden)
+        self.rtg_embed = nn.Linear(1, hidden)
+        self.time_embed = nn.Embedding(max_len, hidden)
+
+        # Transformer Encoder
+        layer = nn.TransformerEncoderLayer(
+            d_model=hidden,
+            nhead=n_heads,
+            dim_feedforward=hidden * 4,
+            batch_first=True,
+            dropout=0.1
+        )
+        self.transformer = nn.TransformerEncoder(layer, num_layers=n_layers)
+
+        # 행동 예측 헤드
+        self.act_head = nn.Linear(hidden, act_dim)
+
+        # Causal Mask 생성을 위한 버퍼 등록 (ONNX export시 사용 안 할 수도 있지만 호환성 위해 유지)
+        # self.register_buffer("mask", torch.tril(torch.ones(max_len * 3, max_len * 3)))
+
+    def forward(self, obs, act, rtg, timesteps):
+        # obs: (B, T, obs_dim)
+        # act: (B, T, act_dim)
+        # rtg: (B, T, 1)
+        # timesteps: (B, T)
+
+        B, T, _ = obs.shape
+
+        # 1. 임베딩 (Embedding)
+        obs_emb = self.obs_embed(obs)          # (B, T, hidden)
+        act_emb = self.act_embed(act)          # (B, T, hidden)
+        rtg_emb = self.rtg_embed(rtg)          # (B, T, hidden)
+        time_emb = self.time_embed(timesteps)  # (B, T, hidden)
+
+        # 2. Timestep Embedding 더하기
+        # 논문에서는 R, s, a 모두에 timestep embedding을 더함
+        obs_emb = obs_emb + time_emb
+        act_emb = act_emb + time_emb
+        rtg_emb = rtg_emb + time_emb
+
+        # 3. Stacking (R_t, s_t, a_t) 순서로 쌓기
+        # (B, T, 3, hidden) -> (B, 3*T, hidden)
+        # dim=2에 stack 후 flatten
+        stacked_inputs = torch.stack((rtg_emb, obs_emb, act_emb), dim=2)
+        stacked_inputs = stacked_inputs.view(B, T * 3, self.hidden)
+
+        # 4. Causal Masking
+        # 현재 시퀀스 길이(3*T)에 맞는 마스크 동적 생성
+        seq_len = T * 3
+        # (seq_len, seq_len) 크기의 마스크 생성
+        # 대각선 위쪽(미래)을 -inf로 채움 (Attention에서 무시됨)
+        # 대각선 포함 아래쪽(과거+현재)은 0으로 유지
+        causal_mask = torch.triu(torch.full((seq_len, seq_len), float('-inf'), device=obs.device), diagonal=1)
+
+        # 5. Transformer Forward
+        # is_causal=True를 명시하여 내부적인 마스크 검사(data-dependent check)를 우회
+        x = self.transformer(stacked_inputs, mask=causal_mask, is_causal=True)
+
+        # 6. Action Prediction
+        # 입력 순서가 (R_t, s_t, a_t) 이므로,
+        # s_t의 출력(index 1, 4, 7...)을 사용하여 a_t를 예측해야 함
+        # x: (B, 3*T, hidden)
+        # reshape -> (B, T, 3, hidden)
+        x = x.view(B, T, 3, self.hidden)
+        
+        # s_t에 해당하는 임베딩 추출 (index 1)
+        # R_t(0), s_t(1), a_t(2)
+        state_preds = x[:, :, 1, :]  # (B, T, hidden)
+
+        action_preds = self.act_head(state_preds)  # (B, T, act_dim)
+
+        return action_preds

Upload/01_Source_Code/Python_Training/train_sequential_ext_RLStep.py

@@ -0,0 +1,181 @@
+import torch
+from torch.utils.data import DataLoader, Subset
+from dataset_dt import TrajectoryDataset
+from model_dt import DecisionTransformer
+import glob
+import os
+import gc
+import time
+import argparse
+import sys
+
+def train_sequential_rl_steps(data_prefix="trajectory_data_part_", output_model="dt_model_trained_rl_limited.pth", target_rl_steps=1000000):
+    log_dir = "./logs"
+    seq_len = 32
+    batch_size = 32
+    learning_rate = 1e-4
+    epochs = 3 
+    # Note: Epochs are still iterated, but we will likely break early in the first epoch 
+    # if target_rl_steps is reached. If target is huge, it might run multiple epochs.
+    # But for "1M RL Steps" on a dataset of >2M, it will stop in Epoch 1.
+    
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"[INFO] Using device: {device}")
+
+    # 1. Initialize Model Dimensions
+    pattern = f"{data_prefix}*.pkl"
+    split_files = sorted(glob.glob(pattern))
+    if not split_files:
+        split_files = sorted(glob.glob(os.path.join(log_dir, pattern)))
+        
+    if not split_files:
+        print(f"[ERROR] No files found matching prefix: {data_prefix}")
+        return
+
+    print(f"[INFO] Found {len(split_files)} split files matching '{data_prefix}'.")
+    
+    # Peek at first file for dimensions
+    print("[INFO] Peeking at first file for dimensions...")
+    temp_dataset = TrajectoryDataset(log_dir, seq_len=seq_len, specific_file=split_files[0])
+    if len(temp_dataset) > 0:
+        obs_dim = temp_dataset[0]["observations"].shape[-1]
+        act_dim = temp_dataset[0]["actions"].shape[-1]
+    else:
+        # Fallback defaults
+        obs_dim = 9
+        act_dim = 3
+        
+    del temp_dataset
+    gc.collect()
+    
+    print(f"[INFO] Obs Dim: {obs_dim}, Act Dim: {act_dim}")
+
+    model = DecisionTransformer(
+        obs_dim=obs_dim,
+        act_dim=act_dim,
+        hidden=256,
+        n_layers=4,
+        n_heads=4,
+        max_len=4096 
+    ).to(device)
+
+    optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)
+    
+    print(f"[INFO] Starting FRESH training with RL STEP LIMIT: {target_rl_steps} (Pre-loading to Memory)")
+
+    # 1. Pre-load Data Phase
+    loaded_datasets = []
+    total_rl_steps_loaded = 0
+    
+    for i, pkl_file in enumerate(split_files):
+        steps_needed = target_rl_steps - total_rl_steps_loaded
+        if steps_needed <= 0:
+            break
+            
+        print(f"[INFO] Pre-loading chunk {i+1}/{len(split_files)}: {pkl_file}")
+        dataset = TrajectoryDataset(log_dir, seq_len=seq_len, specific_file=pkl_file)
+        dataset_len = len(dataset)
+        
+        if dataset_len == 0:
+            continue
+            
+        if dataset_len > steps_needed:
+            print(f"  [LIMIT] Trimming chunk to {steps_needed} samples.")
+            dataset = Subset(dataset, range(steps_needed))
+            loaded_datasets.append(dataset)
+            total_rl_steps_loaded += steps_needed
+            break
+        else:
+            loaded_datasets.append(dataset)
+            total_rl_steps_loaded += dataset_len
+            
+        print(f"  [PROGRESS] Memory Buffer: {total_rl_steps_loaded} / {target_rl_steps}")
+
+    if not loaded_datasets:
+        print("[ERROR] No data loaded! Check file paths.")
+        return
+
+    # 2. Training Phase (Sequential per Chunk, just like original)
+    print(f"[INFO] Data Pre-loading Complete. Starting Training on {len(loaded_datasets)} chunks.")
+    
+    global_gradient_steps = 0
+    
+    for epoch in range(epochs):
+        print(f"\n=== Epoch {epoch+1}/{epochs} ===")
+        epoch_start_time = time.time()
+        
+        for i, dataset in enumerate(loaded_datasets):
+            # Same Batch/Shuffle logic as original
+            loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
+            
+            model.train()
+            chunk_loss = 0.0
+            chunk_steps = 0
+            
+            for batch in loader:
+                states = batch['observations'].to(device)
+                actions = batch['actions'].to(device)
+                returns = batch['returns_to_go'].to(device)
+                timesteps = batch['timesteps'].to(device)
+                
+                # Forward
+                action_preds = model(
+                    obs=states,
+                    act=actions,
+                    rtg=returns,
+                    timesteps=timesteps
+                )
+                
+                # Loss
+                action_target = batch['target_actions'].to(device)
+                loss = torch.mean((action_preds - action_target) ** 2)
+                
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                
+                chunk_loss += loss.item()
+                chunk_steps += 1
+                global_gradient_steps += 1
+                
+                if chunk_steps % 100 == 0:
+                    print(f"  Grad Step {chunk_steps}, Loss: {loss.item():.4f}", end="\r")
+            
+            avg_chunk_loss = chunk_loss / chunk_steps if chunk_steps > 0 else 0
+            print(f"  Chunk {i+1} Finished. Avg Loss: {avg_chunk_loss:.4f}")
+
+        print(f"Epoch {epoch+1} completed in {time.time() - epoch_start_time:.2f}s.")
+        
+        # Save Model per Epoch
+        dir_name, file_name = os.path.split(output_model)
+        epoch_model_path = os.path.join(dir_name, f"E_{epoch+1}_{file_name}")
+        torch.save(model.state_dict(), epoch_model_path)
+        print(f"[INFO] Saved Epoch {epoch+1} Model to: {epoch_model_path}")
+        
+    print(f"\n[DONE] Training Finished.")
+    print(f"  Total RL Steps Processed (cached): {total_rl_steps_loaded}")
+    print(f"  Total Gradient Steps: {global_gradient_steps}")
+        
+    print(f"\n[DONE] Training Finished.")
+    print(f"  Total RL Steps Processed: {total_rl_steps_loaded}")
+    print(f"  Total Gradient Steps: {global_gradient_steps}")
+        
+    # Save Final Model
+    torch.save(model.state_dict(), output_model)
+    print(f"[INFO] Saved Final Model to: {output_model}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Train Decision Transformer with RL Step Limit")
+    parser.add_argument("--prefix", type=str, default="trajectory_data_part_", help="Prefix of the pickle files to load")
+    parser.add_argument("--output", type=str, default="dt_model_1M_RL.pth", help="Output filename")
+    parser.add_argument("--target_rl_steps", type=int, default=1000000, help="Total RL steps (samples) to train on")
+    
+    args = parser.parse_args()
+    
+    print("\n[Configuration]")
+    print(f"  Prefix: {args.prefix}")
+    print(f"  Output: {args.output}")
+    print(f"  Target RL Steps: {args.target_rl_steps}")
+    print("-" * 30)
+    
+    train_sequential_rl_steps(data_prefix=args.prefix, output_model=args.output, target_rl_steps=args.target_rl_steps)

Upload/01_Source_Code/Python_Training/train_sequential_ext_RLStep_For_BC.py

@@ -0,0 +1,183 @@
+import torch
+from torch.utils.data import DataLoader, Subset
+from dataset_dt import TrajectoryDataset
+from model_dt import DecisionTransformer
+import glob
+import os
+import gc
+import time
+import argparse
+import sys
+
+def train_sequential_rl_steps_BC(data_prefix="trajectory_data_part_", output_model="dt_model_trained_rl_limited.pth", target_rl_steps=1000000):
+    log_dir = "./logs"
+    seq_len = 32
+    batch_size = 32
+    learning_rate = 1e-4
+    epochs = 3 
+    # Note: Epochs are still iterated, but we will likely break early in the first epoch 
+    # if target_rl_steps is reached. If target is huge, it might run multiple epochs.
+    # But for "1M RL Steps" on a dataset of >2M, it will stop in Epoch 1.
+    
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"[INFO] Using device: {device}")
+
+    # 1. Initialize Model Dimensions
+    pattern = f"{data_prefix}*.pkl"
+    split_files = sorted(glob.glob(pattern))
+    if not split_files:
+        split_files = sorted(glob.glob(os.path.join(log_dir, pattern)))
+        
+    if not split_files:
+        print(f"[ERROR] No files found matching prefix: {data_prefix}")
+        return
+
+    print(f"[INFO] Found {len(split_files)} split files matching '{data_prefix}'.")
+    
+    # Peek at first file for dimensions
+    print("[INFO] Peeking at first file for dimensions...")
+    temp_dataset = TrajectoryDataset(log_dir, seq_len=seq_len, specific_file=split_files[0])
+    if len(temp_dataset) > 0:
+        obs_dim = temp_dataset[0]["observations"].shape[-1]
+        act_dim = temp_dataset[0]["actions"].shape[-1]
+    else:
+        # Fallback defaults
+        obs_dim = 9
+        act_dim = 3
+        
+    del temp_dataset
+    gc.collect()
+    
+    print(f"[INFO] Obs Dim: {obs_dim}, Act Dim: {act_dim}")
+
+    model = DecisionTransformer(
+        obs_dim=obs_dim,
+        act_dim=act_dim,
+        hidden=256,
+        n_layers=4,
+        n_heads=4,
+        max_len=4096 
+    ).to(device)
+
+    optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)
+    
+    print(f"[INFO] Starting FRESH training with RL STEP LIMIT: {target_rl_steps} (Pre-loading to Memory)")
+
+    # 1. Pre-load Data Phase
+    loaded_datasets = []
+    total_rl_steps_loaded = 0
+    
+    for i, pkl_file in enumerate(split_files):
+        steps_needed = target_rl_steps - total_rl_steps_loaded
+        if steps_needed <= 0:
+            break
+            
+        print(f"[INFO] Pre-loading chunk {i+1}/{len(split_files)}: {pkl_file}")
+        dataset = TrajectoryDataset(log_dir, seq_len=seq_len, specific_file=pkl_file)
+        dataset_len = len(dataset)
+        
+        if dataset_len == 0:
+            continue
+            
+        if dataset_len > steps_needed:
+            print(f"  [LIMIT] Trimming chunk to {steps_needed} samples.")
+            dataset = Subset(dataset, range(steps_needed))
+            loaded_datasets.append(dataset)
+            total_rl_steps_loaded += steps_needed
+            break
+        else:
+            loaded_datasets.append(dataset)
+            total_rl_steps_loaded += dataset_len
+            
+        print(f"  [PROGRESS] Memory Buffer: {total_rl_steps_loaded} / {target_rl_steps}")
+
+    if not loaded_datasets:
+        print("[ERROR] No data loaded! Check file paths.")
+        return
+
+    # 2. Training Phase (Sequential per Chunk, just like original)
+    print(f"[INFO] Data Pre-loading Complete. Starting Training on {len(loaded_datasets)} chunks.")
+    
+    global_gradient_steps = 0
+    
+    for epoch in range(epochs):
+        print(f"\n=== Epoch {epoch+1}/{epochs} ===")
+        epoch_start_time = time.time()
+        
+        for i, dataset in enumerate(loaded_datasets):
+            # Same Batch/Shuffle logic as original
+            loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
+            
+            model.train()
+            chunk_loss = 0.0
+            chunk_steps = 0
+            
+            for batch in loader:
+                states = batch['observations'].to(device)
+                actions = batch['actions'].to(device)
+                returns = batch['returns_to_go'].to(device)
+                timesteps = batch['timesteps'].to(device)
+
+                returns = torch.zeros_like(returns)
+                
+                # Forward
+                action_preds = model(
+                    obs=states,
+                    act=actions,
+                    rtg=returns,
+                    timesteps=timesteps
+                )
+                
+                # Loss
+                action_target = batch['target_actions'].to(device)
+                loss = torch.mean((action_preds - action_target) ** 2)
+                
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                
+                chunk_loss += loss.item()
+                chunk_steps += 1
+                global_gradient_steps += 1
+                
+                if chunk_steps % 100 == 0:
+                    print(f"  Grad Step {chunk_steps}, Loss: {loss.item():.4f}", end="\r")
+            
+            avg_chunk_loss = chunk_loss / chunk_steps if chunk_steps > 0 else 0
+            print(f"  Chunk {i+1} Finished. Avg Loss: {avg_chunk_loss:.4f}")
+
+        print(f"Epoch {epoch+1} completed in {time.time() - epoch_start_time:.2f}s.")
+        
+        # Save Model per Epoch
+        dir_name, file_name = os.path.split(output_model)
+        epoch_model_path = os.path.join(dir_name, f"E_{epoch+1}_{file_name}")
+        torch.save(model.state_dict(), epoch_model_path)
+        print(f"[INFO] Saved Epoch {epoch+1} Model to: {epoch_model_path}")
+        
+    print(f"\n[DONE] Training Finished.")
+    print(f"  Total RL Steps Processed (cached): {total_rl_steps_loaded}")
+    print(f"  Total Gradient Steps: {global_gradient_steps}")
+        
+    print(f"\n[DONE] Training Finished.")
+    print(f"  Total RL Steps Processed: {total_rl_steps_loaded}")
+    print(f"  Total Gradient Steps: {global_gradient_steps}")
+        
+    # Save Final Model
+    torch.save(model.state_dict(), output_model)
+    print(f"[INFO] Saved Final Model to: {output_model}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Train Decision Transformer with RL Step Limit")
+    parser.add_argument("--prefix", type=str, default="trajectory_data_part_", help="Prefix of the pickle files to load")
+    parser.add_argument("--output", type=str, default="dt_model_1M_RL.pth", help="Output filename")
+    parser.add_argument("--target_rl_steps", type=int, default=1000000, help="Total RL steps (samples) to train on")
+    
+    args = parser.parse_args()
+    
+    print("\n[Configuration]")
+    print(f"  Prefix: {args.prefix}")
+    print(f"  Output: {args.output}")
+    print(f"  Target RL Steps: {args.target_rl_steps}")
+    print("-" * 30)
+    
+    train_sequential_rl_steps(data_prefix=args.prefix, output_model=args.output, target_rl_steps=args.target_rl_steps)

Upload/01_Source_Code/Unity_Evaluation/Assets/Demonstrations.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3a5f16fdbeaac7d41bd7fa31ffce8afc
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Upload/01_Source_Code/Unity_Evaluation/Assets/Demonstrations/ShootingAgentDem.demo.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 102e6e2721a20154892b1daacc50240d
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: ' (Unity.MLAgents.Demonstrations.DemonstrationSummary)'
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 7bd65ce151aaa4a41a45312543c56be1, type: 3}

Upload/01_Source_Code/Unity_Evaluation/Assets/Demonstrations/ShootingAgentDem_0.demo.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 181cb179f1a3e6246b03b33023c7dde2
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: ' (Unity.MLAgents.Demonstrations.DemonstrationSummary)'
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 7bd65ce151aaa4a41a45312543c56be1, type: 3}

Upload/01_Source_Code/Unity_Evaluation/Assets/Demonstrations/bulletdodgedemo.demo.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 199173662a2d4ee48b5b90995ce28412
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: ' (Unity.MLAgents.Demonstrations.DemonstrationSummary)'
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 7bd65ce151aaa4a41a45312543c56be1, type: 3}

Upload/01_Source_Code/Unity_Evaluation/Assets/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 95fadbe24a716154b8fd85c4582021ac
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Upload/01_Source_Code/Unity_Evaluation/Assets/Editor/RevisionEvaluation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: cb6e73d0ddbcd4849a005dc4a8cfb10e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Upload/01_Source_Code/Unity_Evaluation/Assets/Editor/RevisionEvaluation/AdditionalEvaluationTools.cs

@@ -0,0 +1,164 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Unity.InferenceEngine;
+using UnityEditor;
+using UnityEngine;
+
+public static class AdditionalEvaluationTools
+{
+    [Serializable] public class InputCase
+    {
+        public string model, sha256, label;
+        public int valid_length;
+        public float[] observations, actions, returns_to_go, expected_output;
+        public int[] timesteps;
+    }
+    [Serializable] public class Fixture { public InputCase[] cases; }
+    [Serializable] public class CaseResult { public string label; public float maximum_absolute_error; }
+    [Serializable] public class Verification
+    {
+        public string status, error, utc, gpu, graphics_api, unity_version;
+        public bool reset_tests_passed;
+        public EvaluationModelParityTests.Result original_model_parity;
+        public List<CaseResult> actual_input_cases = new List<CaseResult>();
+    }
+    [Serializable] public class LatencyRow
+    {
+        public string model, backend, sha256, scope;
+        public int warmup, measurements;
+        public double mean_ms, median_ms, p95_ms, minimum_ms, maximum_ms;
+        public double[] raw_ms;
+    }
+    [Serializable] public class LatencyReport
+    {
+        public string status, error, utc, gpu, graphics_api, unity_version, cpu, os, limitation;
+        public int memory_mb;
+        public List<LatencyRow> models = new List<LatencyRow>();
+    }
+
+    static Fixture Load()
+    {
+        if (!Application.isBatchMode || Application.isPlaying)
+            throw new InvalidOperationException("Run this explicit batch entry point outside Play mode.");
+        if (SystemInfo.graphicsDeviceType == UnityEngine.Rendering.GraphicsDeviceType.Null)
+            throw new InvalidOperationException("A real graphics device is required.");
+        var result = JsonUtility.FromJson<Fixture>(File.ReadAllText(RevisionEvaluationBatch.Argument("-evaluationFixtures")));
+        if (result.cases == null || result.cases.Length != 96) throw new InvalidOperationException("Expected 96 real input cases.");
+        foreach (var c in result.cases)
+            if (Hash(c.model) != c.sha256) throw new InvalidOperationException("Model SHA differs: " + c.model);
+        return result;
+    }
+    static string Hash(string path)
+    {
+        using (var sha = System.Security.Cryptography.SHA256.Create())
+            return BitConverter.ToString(sha.ComputeHash(File.ReadAllBytes(path))).Replace("-", "").ToLowerInvariant();
+    }
+    static void Save(object value)
+    {
+        string path = RevisionEvaluationBatch.Argument("-evaluationReport");
+        if (File.Exists(path)) throw new IOException("Preserve prior report: " + path);
+        File.WriteAllText(path, JsonUtility.ToJson(value, true));
+    }
+    public static void Verify()
+    {
+        var report = new Verification { status = "failed", utc = DateTime.UtcNow.ToString("o"),
+            gpu = SystemInfo.graphicsDeviceName, graphics_api = SystemInfo.graphicsDeviceType.ToString(), unity_version = Application.unityVersion };
+        int code = 1;
+        try
+        {
+            var fixtures = Load();
+            EvaluationSmokeTests.Run();
+            report.reset_tests_passed = true;
+            report.original_model_parity = EvaluationModelParityTests.Run(
+                AssetDatabase.LoadAssetAtPath<ModelAsset>("Assets/Model/FinalModel/E_1_DT_C_5.onnx"),
+                RevisionEvaluationBatch.Argument("-originalFixtures"));
+            foreach (var group in fixtures.cases.GroupBy(c => c.model))
+            {
+                var asset = AssetDatabase.LoadAssetAtPath<ModelAsset>(group.Key);
+                using (var model = new DTModel(ref asset))
+                foreach (var c in group)
+                {
+                    var output = model.Predict(c.observations, c.actions, c.returns_to_go, c.timesteps, 32);
+                    if (output.Length != c.expected_output.Length) throw new InvalidOperationException("Output shape differs.");
+                    float maximum = 0f;
+                    for (int i = 0; i < output.Length; i++)
+                    {
+                        float error = Mathf.Abs(output[i] - c.expected_output[i]);
+                        if (float.IsNaN(error) || error > 1e-4f + 1e-4f * Mathf.Abs(c.expected_output[i]))
+                            throw new InvalidOperationException(c.label + " index=" + i + " error=" + error);
+                        maximum = Mathf.Max(maximum, error);
+                    }
+                    report.actual_input_cases.Add(new CaseResult { label = c.label, maximum_absolute_error = maximum });
+                }
+            }
+            report.status = "passed"; code = 0;
+            Debug.Log("[Additional] Real-input ONNX Runtime/Unity parity passed: " + report.actual_input_cases.Count);
+        }
+        catch (Exception e) { report.error = e.ToString(); Debug.LogException(e); }
+        finally { Save(report); EditorApplication.Exit(code); }
+    }
+
+    static LatencyRow Measure(string path, string backend, Action<int> predict)
+    {
+        const int warmup = 200, n = 2000;
+        for (int i = 0; i < warmup; i++) predict(i);
+        var values = new double[n];
+        for (int i = 0; i < n; i++)
+        {
+            long start = System.Diagnostics.Stopwatch.GetTimestamp();
+            predict(i + warmup);
+            values[i] = 1000.0 * (System.Diagnostics.Stopwatch.GetTimestamp() - start) / System.Diagnostics.Stopwatch.Frequency;
+        }
+        var sorted = values.OrderBy(x => x).ToArray();
+        return new LatencyRow { model = path, backend = backend, sha256 = Hash(path), warmup = warmup, measurements = n,
+            scope = "Synchronous model call including tensor construction/scheduling/all action-output readback/disposal; excludes source array preparation and scene control",
+            raw_ms = values, mean_ms = values.Average(), median_ms = .5 * (sorted[n/2-1] + sorted[n/2]),
+            p95_ms = sorted[(int)Math.Ceiling(.95*n)-1], minimum_ms = sorted[0], maximum_ms = sorted[n-1] };
+    }
+    public static void MeasureLatency()
+    {
+        var report = new LatencyReport { status = "failed", utc = DateTime.UtcNow.ToString("o"),
+            gpu = SystemInfo.graphicsDeviceName, graphics_api = SystemInfo.graphicsDeviceType.ToString(), unity_version = Application.unityVersion,
+            cpu = SystemInfo.processorType, os = SystemInfo.operatingSystem, memory_mb = SystemInfo.systemMemorySize,
+            limitation = "Batch Editor, fixed hardware/backend, one measurement session. Not rendered FPS or deployment-build timing. PPO raw-model call excludes ML-Agents policy overhead, which is included in separate scene loop measurements." };
+        int code = 1;
+        try
+        {
+            var fixtures = Load();
+            foreach (string path in new[] { "Assets/Model/FinalModel/E_3_DT_S_100.onnx", "Assets/Model/FinalModel/BCModels/E_3_DT_BC_100.onnx" })
+            {
+                var inputs = fixtures.cases.Where(c => c.model == path).ToArray();
+                var asset = AssetDatabase.LoadAssetAtPath<ModelAsset>(path);
+                using (var model = new DTModel(ref asset))
+                    report.models.Add(Measure(path, model.BackendName, i => {
+                        var c = inputs[i % inputs.Length];
+                        model.Predict(c.observations, c.actions, c.returns_to_go, c.timesteps, 32);
+                    }));
+            }
+            string ppoPath = "Assets/Model/V12/V12 PPO.onnx";
+            var ppoAsset = AssetDatabase.LoadAssetAtPath<ModelAsset>(ppoPath);
+            var ppoObservations = fixtures.cases.Where(c => c.model.EndsWith("E_3_DT_S_100.onnx"))
+                .Select(c => c.observations.Skip(9*(c.valid_length-1)).Take(9).ToArray()).ToArray();
+            var mask = new[] { 1f, 1f, 1f, 1f };
+            using (var worker = new Worker(ModelLoader.Load(ppoAsset), Unity.InferenceEngine.DeviceType.CPU))
+                report.models.Add(Measure(ppoPath, worker.backendType.ToString(), i => {
+                    using (var obs = new Tensor<float>(new TensorShape(1,9), ppoObservations[i % ppoObservations.Length]))
+                    using (var masks = new Tensor<float>(new TensorShape(1,4), mask))
+                    {
+                        worker.SetInput("obs_0", obs); worker.SetInput("action_masks", masks); worker.Schedule();
+                        var continuous = worker.PeekOutput("continuous_actions") as Tensor<float>;
+                        var discrete = worker.PeekOutput("discrete_actions") as Tensor<int>;
+                        if (continuous == null || discrete == null) throw new InvalidOperationException("PPO output type differs.");
+                        continuous.DownloadToArray(); discrete.DownloadToArray();
+                    }
+                }));
+            report.status = "passed"; code = 0;
+        }
+        catch (Exception e) { report.error = e.ToString(); Debug.LogException(e); }
+        finally { Save(report); EditorApplication.Exit(code); }
+    }
+}
+#endif

Upload/01_Source_Code/Unity_Evaluation/Assets/Editor/RevisionEvaluation/AdditionalEvaluationTools.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 0432a35114a16284b91b3ceafb8bee02

Upload/01_Source_Code/Unity_Evaluation/Assets/Editor/RevisionEvaluation/EvaluationModelParityTests.cs

@@ -0,0 +1,120 @@
+#if UNITY_EDITOR
+using System;
+using System.IO;
+using Unity.InferenceEngine;
+using UnityEditor;
+using UnityEngine;
+
+// Uses a synthetic episode processed by the supplied dataset_dt.py and model_dt.py.
+// Validates the actual C# buffer, output selection, and Unity inference together.
+public static class EvaluationModelParityTests
+{
+    [Serializable] public class Step
+    {
+        public float[] observations, recorded_action;
+        public float rtg;
+    }
+    [Serializable] public class Fixture
+    {
+        public int timestep, valid_length;
+        public bool is_bc;
+        public float[] observations, actions, returns_to_go, expected_action;
+        public int[] timesteps;
+    }
+    [Serializable] public class FixtureSet
+    {
+        public string model, onnx_sha256;
+        public int seq_len;
+        public Step[] steps;
+        public Fixture[] cases;
+    }
+
+    [MenuItem("Tools/Revision Evaluation/Run Selected Model Parity Tests")]
+    public static void Run()
+    {
+        if (Application.isPlaying) throw new InvalidOperationException("Run parity tests outside Play mode.");
+        var asset = Selection.activeObject as ModelAsset;
+        if (asset == null) throw new InvalidOperationException("Select the supplied E_1_DT_C_5 ONNX asset in Project first.");
+        string path = EditorUtility.OpenFilePanel("Select E_1_DT_C_5_sequence_fixtures.json", "", "json");
+        if (string.IsNullOrEmpty(path)) return;
+        Run(asset, path);
+    }
+
+    [Serializable] public class Result
+    {
+        public int cases_passed;
+        public float maximum_absolute_error;
+        public string backend;
+    }
+
+    public static Result Run(ModelAsset asset, string path)
+    {
+        if (Application.isPlaying) throw new InvalidOperationException("Run parity tests outside Play mode.");
+        if (asset == null) throw new ArgumentNullException(nameof(asset));
+        var fixtures = JsonUtility.FromJson<FixtureSet>(File.ReadAllText(path));
+        if (fixtures == null || fixtures.cases == null || fixtures.cases.Length != 18 ||
+            fixtures.steps == null || fixtures.steps.Length != 1000 || fixtures.seq_len != 32)
+            throw new InvalidOperationException("Select the fixture file included in this package.");
+        string assetPath = AssetDatabase.GetAssetPath(asset);
+        if (!assetPath.EndsWith(".onnx", StringComparison.OrdinalIgnoreCase))
+            throw new InvalidOperationException("Select the ONNX asset itself.");
+        using (var sha = System.Security.Cryptography.SHA256.Create())
+        {
+            string hash = BitConverter.ToString(sha.ComputeHash(File.ReadAllBytes(assetPath))).Replace("-", "").ToLowerInvariant();
+            if (hash != fixtures.onnx_sha256)
+                throw new InvalidOperationException("Selected ONNX differs from the verified E_1_DT_C_5 file.");
+        }
+        int passed = 0; float maximumError = 0f;
+        string backend;
+        using (var model = new DTModel(ref asset))
+        {
+            backend = model.BackendName;
+            foreach (bool isBC in new[] { false, true })
+            {
+                var buffer = new DTSequenceBuffer(32, 9, 3);
+                var previous = new float[3];
+                for (int t = 0; t < fixtures.steps.Length; t++)
+                {
+                    Step step = fixtures.steps[t];
+                    buffer.AddStep(step.observations, previous, isBC ? 0f : step.rtg);
+                    foreach (var c in fixtures.cases)
+                    {
+                        if (c.timestep != t || c.is_bc != isBC) continue;
+                        string label = $"t={t}, zeroRTG={isBC}";
+                        if (buffer.CurrentLength() != c.valid_length) throw new InvalidOperationException(label + ": valid length differs.");
+                        CheckArray(buffer.GetObsArray(), c.observations, label + " observations", 1e-6f);
+                        CheckArray(buffer.GetActArray(), c.actions, label + " actions", 1e-6f);
+                        CheckArray(buffer.GetRTGArray(), c.returns_to_go, label + " RTG", 1e-6f);
+                        var times = buffer.GetTimestepArray();
+                        for (int j = 0; j < 32; j++)
+                            if (times[j] != c.timesteps[j]) throw new InvalidOperationException(label + ": absolute timestep differs.");
+                        var output = model.Predict(buffer.GetObsArray(), buffer.GetActArray(), buffer.GetRTGArray(), times, 32);
+                        var selected = buffer.SelectCurrentAction(output);
+                        maximumError = Mathf.Max(maximumError, CheckArray(selected, c.expected_action, label + " prediction", 1e-4f));
+                        passed++;
+                    }
+                    previous = step.recorded_action;
+                }
+            }
+        }
+        if (passed != 18) throw new InvalidOperationException("Not every fixture was executed.");
+        Debug.Log($"[Evaluation] {passed} buffer/Unity/PyTorch parity cases passed. Maximum absolute prediction error={maximumError:G9}. Synthetic inputs; not an evaluation success rate.");
+        return new Result { cases_passed = passed, maximum_absolute_error = maximumError, backend = backend };
+    }
+
+    private static float CheckArray(float[] actual, float[] expected, string label, float tolerance)
+    {
+        if (actual == null || expected == null || actual.Length != expected.Length)
+            throw new InvalidOperationException(label + ": shape differs.");
+        float maxError = 0f;
+        for (int i = 0; i < actual.Length; i++)
+        {
+            float error = Mathf.Abs(actual[i] - expected[i]);
+            if (!EvaluationProtocol.Finite(actual[i]) || error > tolerance + tolerance * Mathf.Abs(expected[i]))
+                throw new InvalidOperationException($"{label}, index {i}: difference={error:G9}");
+            maxError = Mathf.Max(maxError, error);
+        }
+        return maxError;
+    }
+}
+#endif

Upload/01_Source_Code/Unity_Evaluation/Assets/Editor/RevisionEvaluation/EvaluationModelParityTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f34819e85eea181409a73db95d83142a

Upload/01_Source_Code/Unity_Evaluation/Assets/Editor/RevisionEvaluation/EvaluationSmokeTests.cs

@@ -0,0 +1,115 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+
+// Optional: copy this file into Assets/Editor, then use Tools/Revision Evaluation/Run Reset Tests.
+// This does not load models or validate inference accuracy.
+public static class EvaluationSmokeTests
+{
+    [MenuItem("Tools/Revision Evaluation/Run Reset Tests")]
+    public static void Run()
+    {
+        if (Application.isPlaying) throw new InvalidOperationException("Run reset tests outside Play mode.");
+        var saved = UnityEngine.Random.state;
+        var root = new GameObject("EvaluationSmokeTest");
+        try
+        {
+            var barrel = new GameObject("Barrel");
+            barrel.transform.SetParent(root.transform, false);
+            var targets = new List<EnemyDummy>();
+            for (int i = 0; i < 20; i++)
+            {
+                var go = new GameObject("Target" + i);
+                go.transform.SetParent(root.transform, false);
+                targets.Add(go.AddComponent<EnemyDummy>());
+            }
+            string first = JsonUtility.ToJson(EvaluationProtocol.ResetEnvironment(
+                root.transform, barrel.transform, targets, 20, 42, 0));
+            EvaluationProtocol.AdvanceTargets(targets, 20);
+            string trajectory = JsonUtility.ToJson(targets[0].CaptureEvaluationState());
+            // Simulate a different preceding episode/model and unrelated random draws.
+            for (int i = 0; i < 100; i++) UnityEngine.Random.Range(0f, 100f);
+            EvaluationProtocol.ResetEnvironment(root.transform, barrel.transform, targets, 20, 42, 1);
+            EvaluationProtocol.AdvanceTargets(targets, 100);
+            string repeated = JsonUtility.ToJson(EvaluationProtocol.ResetEnvironment(
+                root.transform, barrel.transform, targets, 20, 42, 0));
+            Check(first == repeated, "Same episode seed must restore the same initial state.");
+            // First activation's Start must not randomize an already prepared evaluation target.
+            var beforeStart = JsonUtility.ToJson(targets[0].CaptureEvaluationState());
+            typeof(EnemyDummy).GetMethod("Start", BindingFlags.NonPublic | BindingFlags.Instance)
+                .Invoke(targets[0], null);
+            Check(beforeStart == JsonUtility.ToJson(targets[0].CaptureEvaluationState()), "Start changed evaluation state.");
+            EvaluationProtocol.AdvanceTargets(targets, 20);
+            Check(trajectory == JsonUtility.ToJson(targets[0].CaptureEvaluationState()), "Motion depends on prior episode state.");
+            string different = JsonUtility.ToJson(EvaluationProtocol.ResetEnvironment(
+                root.transform, barrel.transform, targets, 20, 42, 1));
+            Check(first != different, "Distinct episode seeds must produce distinct states.");
+            var stateBefore = UnityEngine.Random.state;
+            float expectedNextDraw = UnityEngine.Random.value;
+            UnityEngine.Random.state = stateBefore;
+            EvaluationProtocol.ResetEnvironment(root.transform, barrel.transform, targets, 10, 42, 0);
+            Check(expectedNextDraw == UnityEngine.Random.value, "Reset leaked global random state.");
+            Check(!targets[19].gameObject.activeSelf, "Inactive targets were not disabled.");
+            var buffer = new DTSequenceBuffer(2, 9, 3);
+            buffer.AddStep(new float[9], new float[3], 7f);
+            buffer.Clear();
+            Check(buffer.CurrentLength() == 0, "Sequence history survived Clear.");
+            buffer.AddStep(new float[9], new float[3], 0f);
+            Check(buffer.GetRTGArray()[0] == 0f, "RTG history survived Clear.");
+            buffer.AddStep(new float[9], new float[3], 1f);
+            buffer.AddStep(new float[9], new float[3], 2f);
+            Check(buffer.GetTimestepArray()[0] == 1 && buffer.GetTimestepArray()[1] == 2,
+                "Sliding windows must retain absolute episode timesteps.");
+            buffer.Clear();
+            float[] obs = new float[9]; obs[0] = 123f;
+            buffer.AddStep(obs, new float[3], 35f);
+            Check(buffer.CurrentLength() == 1 && buffer.GetObsArray()[0] == 123f &&
+                buffer.GetObsArray()[9] == 0f && buffer.GetRTGArray()[1] == 0f,
+                "Early episodes must right-pad future positions with zeros.");
+            float aim20 = EvaluationReward.AimScore(Vector3.forward,
+                Quaternion.Euler(0f,20f,0f) * Vector3.forward);
+            Check(!EvaluationReward.ShouldCast(true,true,aim20), "20-degree aim must not pass the training fire gate.");
+            Check(EvaluationReward.ShouldCast(true,true,1f), "Perfect aim should allow a requested shot.");
+            Check(!EvaluationReward.ShouldCast(false,true,1f), "No requested shot must not fire.");
+            Check(Mathf.Abs(EvaluationReward.Step(true,true,1f,-0.001f)-0.01f)<1e-7f,
+                "Perfect-aim firing step reward differs from training.");
+            Check(Mathf.Abs(EvaluationReward.Step(true,false,0f,-0.001f)+0.011f)<1e-7f,
+                "Unaligned non-firing penalty differs from training.");
+            Check(EvaluationReward.Terminal(0,1000,1000) == 2f,
+                "Success at the action limit must retain its victory bonus.");
+            Check(Mathf.Abs(EvaluationReward.Terminal(3,1000,1000)+0.03f)<1e-7f,
+                "Timeout must include the remaining-target penalty.");
+            Check(EvaluationReward.Terminal(3,999,1000) == 0f &&
+                !EvaluationReward.IsTerminal(3,999,1000), "Episode ended before its action limit.");
+            Check(Mathf.Abs(EvaluationReward.Step(true,true,0f,-0.001f)+0.002f)<1e-7f,
+                "Unaligned fire request must receive the training penalty without a raycast.");
+            buffer.Clear();
+            float[] previous = { 0.1f, -0.2f, 1f };
+            buffer.AddStep(obs, previous, 35f);
+            previous[2] = 0f; obs[0] = -1f;
+            Check(buffer.GetActArray()[2] == 1f && buffer.GetObsArray()[0] == 123f,
+                "Caller mutation corrupted stored history.");
+            float[] predictions = { 1f, 2f, 3f, 9f, 8f, 7f };
+            Check(buffer.SelectCurrentAction(predictions)[0] == 1f,
+                "Early prediction selected a padded future position.");
+            buffer.AddStep(new float[9], new float[3], 34f);
+            Check(buffer.SelectCurrentAction(predictions)[0] == 9f,
+                "Full-window prediction did not select the current position.");
+            Debug.Log("[Evaluation] Reset, motion replay, startup, RNG isolation and buffer smoke tests passed.");
+        }
+        finally
+        {
+            UnityEngine.Object.DestroyImmediate(root);
+            UnityEngine.Random.state = saved;
+        }
+    }
+
+    private static void Check(bool condition, string message)
+    {
+        if (!condition) throw new InvalidOperationException(message);
+    }
+}
+#endif

Upload/01_Source_Code/Unity_Evaluation/Assets/Editor/RevisionEvaluation/EvaluationSmokeTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 22355b2e48385834ea8de2593e418ad7

Upload/01_Source_Code/Unity_Evaluation/Assets/Editor/RevisionEvaluation/RevisionEvaluationBatch.cs

@@ -0,0 +1,318 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Unity.InferenceEngine;
+using Unity.MLAgents;
+using Unity.MLAgents.Policies;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+// Batch entry points run only when explicitly requested with -executeMethod.
+[InitializeOnLoad]
+public static class RevisionEvaluationBatch
+{
+    const string Pending = "RevisionEvaluationBatch.pending";
+    const string Failure = "RevisionEvaluationBatch.failure";
+    const string Started = "RevisionEvaluationBatch.started";
+    const string Played = "RevisionEvaluationBatch.played";
+    const string Done = "RevisionEvaluationBatch.done";
+    const string PpoModel = "Assets/Model/V12/V12 PPO.onnx";
+    const string DtModel = "Assets/Model/FinalModel/E_1_DT_C_5.onnx";
+
+    [Serializable] public class Job
+    {
+        public string id, policy, scene, output, report;
+        public string[] models;
+        public int episodes = 2, targets = 10, seed = 42, max_steps = 1000;
+        public float initial_rtg = 35f;
+        public bool rtg_sensitivity, bc_legacy_rtg, record_timing;
+        public float time_scale_override;
+        public string experiment_kind;
+        public double timeout_seconds = 7200;
+    }
+    [Serializable] class Verification
+    {
+        public string status, error, unity_version, gpu, graphics_api, utc;
+        public bool compilation_passed, reset_tests_passed;
+        public EvaluationModelParityTests.Result parity;
+    }
+    [Serializable] class RunReport
+    {
+        public string status, error, utc, unity_version, gpu, graphics_api;
+        public Job job;
+        public string source_scene = "Assets/Scenes/Shooting.unity";
+        public string rig_source, ppo_model, ppo_inference_device;
+        public bool ppo_deterministic;
+        public int[] ppo_discrete_branch_sizes;
+        public float fixed_delta_time, time_scale, rotation_speed, shoot_distance, step_penalty;
+        public string[] files;
+        public double wall_seconds;
+    }
+
+    static RevisionEvaluationBatch()
+    {
+        EditorApplication.update += Monitor;
+        Application.logMessageReceived += OnLog;
+    }
+
+    public static string Argument(string name)
+    {
+        var args = Environment.GetCommandLineArgs();
+        for (int i = 0; i + 1 < args.Length; i++) if (args[i] == name) return args[i + 1];
+        throw new ArgumentException("Missing command-line argument " + name);
+    }
+
+    public static void Verify()
+    {
+        var result = new Verification {
+            status = "failed", unity_version = Application.unityVersion,
+            gpu = SystemInfo.graphicsDeviceName, graphics_api = SystemInfo.graphicsDeviceType.ToString(),
+            utc = DateTime.UtcNow.ToString("o"), compilation_passed = true
+        };
+        int code = 1;
+        try
+        {
+            if (SystemInfo.graphicsDeviceType == UnityEngine.Rendering.GraphicsDeviceType.Null)
+                throw new InvalidOperationException("GPU verification requires a graphics device; omit -nographics.");
+            EvaluationSmokeTests.Run();
+            result.reset_tests_passed = true;
+            result.parity = EvaluationModelParityTests.Run(
+                AssetDatabase.LoadAssetAtPath<ModelAsset>(DtModel), Argument("-evaluationFixtures"));
+            result.status = "passed";
+            code = 0;
+        }
+        catch (Exception error) { result.error = error.ToString(); Debug.LogException(error); }
+        finally
+        {
+            WriteJson(Argument("-evaluationReport"), result);
+            EditorApplication.Exit(code);
+        }
+    }
+
+    public static void Run()
+    {
+        try
+        {
+            if (!Application.isBatchMode) throw new InvalidOperationException("Use this entry point only in batch mode on the working copy.");
+            Job job = JsonUtility.FromJson<Job>(File.ReadAllText(Argument("-evaluationJob")));
+            if (job == null || job.episodes < 1 || (job.targets != 10 && job.targets != 15 && job.targets != 20) ||
+                (job.policy != "PPO" && job.policy != "DT") || job.models == null || job.models.Length == 0)
+                throw new InvalidOperationException("Invalid evaluation job.");
+            if (Directory.Exists(job.output) && Directory.GetFiles(job.output, "*.json", SearchOption.AllDirectories).Length > 0)
+                throw new InvalidOperationException("Use a fresh result directory for every job.");
+            Directory.CreateDirectory(job.output);
+            var report = Prepare(job);
+            WriteJson(job.report, report);
+            SessionState.SetString(Pending, JsonUtility.ToJson(job));
+            SessionState.SetString(Failure, "");
+            SessionState.SetString(Started, DateTime.UtcNow.ToString("o"));
+            SessionState.SetBool(Played, false);
+            SessionState.SetBool(Done, false);
+            EditorApplication.isPlaying = true;
+        }
+        catch (Exception error)
+        {
+            Debug.LogException(error);
+            EditorApplication.Exit(1);
+        }
+    }
+
+    static RunReport Prepare(Job job)
+    {
+        if (job.time_scale_override > 0) Time.timeScale = job.time_scale_override;
+        var scene = EditorSceneManager.OpenScene("Assets/Scenes/Shooting.unity", OpenSceneMode.Single);
+        var ppo = scene.GetRootGameObjects().SelectMany(g => g.GetComponentsInChildren<DroneAgent_For_Testing>(true)).Single();
+        string rigSource = HierarchyPath(ppo.transform);
+        var barrel = ppo.gunBarrel;
+        var targets = new List<EnemyDummy>(ppo.enemies);
+        if (barrel == null || targets.Count != 10 || targets.Any(e => e == null) || targets.Distinct().Count() != 10)
+            throw new InvalidOperationException("Expected the original PPO rig with ten unique targets.");
+        var behavior = ppo.GetComponent<BehaviorParameters>();
+        var requester = ppo.GetComponent<DecisionRequester>();
+        if (behavior == null || requester == null || AssetDatabase.GetAssetPath(behavior.Model) != PpoModel)
+            throw new InvalidOperationException("Original PPO rig/model differs from the inspected project.");
+        if (behavior.BrainParameters.VectorObservationSize != 9 ||
+            behavior.BrainParameters.ActionSpec.NumContinuousActions != 2 ||
+            !behavior.BrainParameters.ActionSpec.BranchSizes.SequenceEqual(new[] { 2, 2 }))
+            throw new InvalidOperationException("PPO observation/action contract mismatch.");
+
+        // Disable the original scene before configuring anything; activate only the common rig.
+        foreach (var go in scene.GetRootGameObjects()) go.SetActive(false);
+        foreach (var enemy in scene.GetRootGameObjects().SelectMany(g => g.GetComponentsInChildren<EnemyDummy>(true)))
+            enemy.gameObject.SetActive(false);
+        foreach (var agent in scene.GetRootGameObjects().SelectMany(g => g.GetComponentsInChildren<Agent>(true)))
+        {
+            agent.enabled = false;
+            if (agent.gameObject != ppo.gameObject) agent.gameObject.SetActive(false);
+        }
+        foreach (var controller in scene.GetRootGameObjects().SelectMany(g => g.GetComponentsInChildren<DTController_For_Testing>(true)))
+        {
+            controller.enabled = false;
+            if (controller.gameObject != ppo.gameObject) controller.gameObject.SetActive(false);
+        }
+        foreach (var decision in scene.GetRootGameObjects().SelectMany(g => g.GetComponentsInChildren<DecisionRequester>(true)))
+            decision.enabled = false;
+
+        // 15/20-target conditions extend the same collider/motion settings, preserving the first ten and their order.
+        for (int i = targets.Count; i < job.targets; i++)
+        {
+            var clone = UnityEngine.Object.Instantiate(targets[i % 10].gameObject, targets[i % 10].transform.parent);
+            clone.name = "RevisionTarget_" + i;
+            clone.SetActive(false);
+            targets.Add(clone.GetComponent<EnemyDummy>());
+        }
+        foreach (var enemy in targets)
+        {
+            if (enemy.GetComponent<Collider>() == null || (ppo.enemyLayer.value & (1 << enemy.gameObject.layer)) == 0 ||
+                enemy.GetComponentsInChildren<Rigidbody>(true).Any(r => !r.isKinematic) ||
+                enemy.GetComponentsInChildren<Animator>(true).Any(a => a.enabled) ||
+                enemy.GetComponents<MonoBehaviour>().Any(b => b != enemy && b.enabled))
+                throw new InvalidOperationException("Target has unexpected collision or external movement settings: " + enemy.name);
+            ActivateAncestors(enemy.transform.parent);
+        }
+        ActivateAncestors(ppo.transform);
+        foreach (var target in targets) target.gameObject.SetActive(false); // ResetEnvironment owns first activation.
+        foreach (var other in ppo.GetComponents<Agent>().Where(a => a != ppo).ToArray())
+            UnityEngine.Object.DestroyImmediate(other);
+
+        ppo.maxTestEpisodes = job.episodes;
+        ppo.maxEpisodeSteps = job.max_steps;
+        ppo.testSeed = job.seed;
+        ppo.EnemyCount = job.targets;
+        ppo.enemies = targets;
+        ppo.rotationSpeed = 100f;
+        ppo.shootDistance = 50f;
+        ppo.stepPenalty = EvaluationReward.DefaultStepPenalty;
+        ppo.outputFileName = "V12_PPO.json";
+        ppo.recordTiming = job.record_timing;
+        ppo.experimentKind = job.experiment_kind;
+        behavior.BehaviorType = BehaviorType.InferenceOnly;
+        requester.DecisionPeriod = 1;
+        requester.DecisionStep = 0;
+        requester.TakeActionsBetweenDecisions = false;
+
+        if (job.policy == "PPO")
+        {
+            if (job.models.Length != 1 || job.models[0] != PpoModel) throw new InvalidOperationException("Unexpected PPO model.");
+            ppo.enabled = true;
+            requester.enabled = true;
+        }
+        else
+        {
+            // No PPO component is allowed to initialize an Academy/policy during DT evaluation.
+            var go = ppo.gameObject;
+            var mask = ppo.enemyLayer;
+            UnityEngine.Object.DestroyImmediate(requester);
+            UnityEngine.Object.DestroyImmediate(ppo);
+            var controller = go.GetComponent<DTController_For_Testing>() ?? go.AddComponent<DTController_For_Testing>();
+            controller.modelAssets = job.models.Select(path => AssetDatabase.LoadAssetAtPath<ModelAsset>(path)).ToList();
+            if (controller.modelAssets.Any(model => model == null)) throw new InvalidOperationException("A requested model is missing.");
+            controller.gunBarrel = barrel;
+            controller.enemies = targets;
+            controller.enemyLayer = mask;
+            controller.EnemyCount = job.targets;
+            controller.maxTestEpisodes = job.episodes;
+            controller.maxEpisodeSteps = job.max_steps;
+            controller.testSeed = job.seed;
+            controller.initialRTG = job.initial_rtg;
+            controller.RTG_TEST = job.rtg_sensitivity;
+            controller.diagnosticLegacyBcRtg = job.bc_legacy_rtg;
+            controller.recordTiming = job.record_timing;
+            controller.experimentKind = job.experiment_kind;
+            controller.policyMode = DTController_For_Testing.PolicyMode.AutoFromModelName;
+            controller.rotationSpeed = 100f;
+            controller.shootDistance = 50f;
+            controller.stepPenalty = EvaluationReward.DefaultStepPenalty;
+            controller.traceEpisodes = 2;
+            controller.laserLine = controller.laserLineToEnemy = null;
+            controller.enabled = true;
+        }
+        // Keep the original time scale and fixed timestep; target simulation advances by action count.
+        var activeAgents = scene.GetRootGameObjects().SelectMany(g => g.GetComponentsInChildren<Agent>(true))
+            .Where(a => a.isActiveAndEnabled).ToArray();
+        var activeDt = scene.GetRootGameObjects().SelectMany(g => g.GetComponentsInChildren<DTController_For_Testing>(true))
+            .Where(a => a.isActiveAndEnabled).ToArray();
+        if (activeAgents.Length != (job.policy == "PPO" ? 1 : 0) || activeDt.Length != (job.policy == "DT" ? 1 : 0))
+            throw new InvalidOperationException("The scene must have exactly one active evaluator.");
+        Directory.CreateDirectory(Path.GetDirectoryName(job.scene));
+        if (!EditorSceneManager.SaveScene(scene, job.scene)) throw new IOException("Could not save evaluation scene.");
+        AssetDatabase.SaveAssets();
+        return new RunReport {
+            status = "running", job = job, utc = DateTime.UtcNow.ToString("o"),
+            unity_version = Application.unityVersion, gpu = SystemInfo.graphicsDeviceName,
+            graphics_api = SystemInfo.graphicsDeviceType.ToString(), rig_source = rigSource,
+            ppo_model = AssetDatabase.GetAssetPath(behavior.Model),
+            ppo_inference_device = behavior.InferenceDevice.ToString(), ppo_deterministic = behavior.DeterministicInference,
+            ppo_discrete_branch_sizes = behavior.BrainParameters.ActionSpec.BranchSizes,
+            fixed_delta_time = Time.fixedDeltaTime, time_scale = Time.timeScale,
+            rotation_speed = 100f, shoot_distance = 50f, step_penalty = EvaluationReward.DefaultStepPenalty
+        };
+    }
+
+    static void ActivateAncestors(Transform transform)
+    {
+        if (transform == null) return;
+        ActivateAncestors(transform.parent);
+        transform.gameObject.SetActive(true);
+    }
+    static string HierarchyPath(Transform transform)
+    {
+        return transform.parent == null ? transform.name : HierarchyPath(transform.parent) + "/" + transform.name;
+    }
+    static void OnLog(string condition, string stack, LogType type)
+    {
+        if (string.IsNullOrEmpty(SessionState.GetString(Pending, ""))) return;
+        if (type == LogType.Error || type == LogType.Exception || type == LogType.Assert)
+            SessionState.SetString(Failure, condition + "\n" + stack);
+    }
+    static void Monitor()
+    {
+        string json = SessionState.GetString(Pending, "");
+        if (string.IsNullOrEmpty(json)) return;
+        try
+        {
+            var job = JsonUtility.FromJson<Job>(json);
+            if (EditorApplication.isPlaying) SessionState.SetBool(Played, true);
+            double elapsed = (DateTime.UtcNow - DateTime.Parse(SessionState.GetString(Started, ""), null,
+                System.Globalization.DateTimeStyles.RoundtripKind)).TotalSeconds;
+            var files = Directory.GetFiles(job.output, "*.json", SearchOption.AllDirectories);
+            string failure = SessionState.GetString(Failure, "");
+            if (elapsed > job.timeout_seconds) failure = "Evaluation exceeded the job timeout.";
+            bool finished = SessionState.GetBool(Played, false) && files.Length == job.models.Length;
+            if (SessionState.GetBool(Played, false) && !EditorApplication.isPlayingOrWillChangePlaymode && !SessionState.GetBool(Done, false))
+                failure = "Play mode stopped before expected results were saved.";
+            if (!finished && string.IsNullOrEmpty(failure)) return;
+            SessionState.SetBool(Done, true);
+            if (EditorApplication.isPlayingOrWillChangePlaymode)
+            {
+                if (!string.IsNullOrEmpty(failure)) SessionState.SetString(Failure, failure);
+                EditorApplication.isPlaying = false;
+                return;
+            }
+            var report = JsonUtility.FromJson<RunReport>(File.ReadAllText(job.report));
+            report.status = string.IsNullOrEmpty(failure) && finished ? "passed" : "failed";
+            report.error = failure;
+            report.files = files;
+            report.wall_seconds = elapsed;
+            WriteJson(job.report, report);
+            SessionState.EraseString(Pending);
+            EditorApplication.Exit(report.status == "passed" ? 0 : 1);
+        }
+        catch (Exception error)
+        {
+            SessionState.EraseString(Pending);
+            Debug.LogException(error);
+            EditorApplication.Exit(1);
+        }
+    }
+    static void WriteJson(string path, object value)
+    {
+        Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(path)));
+        File.WriteAllText(path, JsonUtility.ToJson(value, true));
+    }
+}
+#endif

Upload/01_Source_Code/Unity_Evaluation/Assets/Editor/RevisionEvaluation/RevisionEvaluationBatch.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: dd26dc65c3c7b2a4cb1925a8043b9afe

Upload/01_Source_Code/Unity_Evaluation/Assets/ML-Agents.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a4feaeeb0ad999f469361613b1ef969e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Upload/01_Source_Code/Unity_Evaluation/Assets/ML-Agents/Configs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b7fd679a87b446e409cdf1e1f333624b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: