Lesson:research autopilot 20260720t030001z

신뢰도 중간 마지막 수정: 2026-07-20T04:31:39.659083Z

메모 편집

제목	Research findings 20260720T030001Z: 0 negative/inconclusive, 1 mixed, 3 positive
궁금했던 점	What did the validated experiments or analyses establish, including useful negative results and the conditions under which they apply?
해본 것	- mlir-fft-compiler [scientific outcome=positive]: On GPU lowering of dense complex contractions, register pressure acts as a threshold at the architectural register cap, not as a continuous occupancy penalty. Re-analysis of four L40S (sm_89, complex128) configurations shows achieved occupancy spans only 5.53 pp (14.34-19.87%) and picks the faster lowering at 0 of 2 shapes -- it is anti-correlated with runtime, so an occupancy-knee cost model cannot be rescued by recalibration. The discriminator is spilling past the 255-register cap: below it the Gauss-amortized lowering wins on issue slots alone ((K-1)/(4K), with measured dynamic instructions within 2.5% of the closed forms 3KJ+J and 4KJ); above it, excess registers convert arithmetic savi…; validation: Full suite: 1205 tests pass (105 new in tests/test_spill_model.py), 0 failures; H5b spill predicate agrees with nvcc's static spill bytes at 4/4 measured hardware points, zero fitted parameters; H5c implied reload counts 87.29 (complex_spec) vs 89.16 (real_fold) agree to 2.15% across two different schedules; predicted spill bytes within 1.7% of measured (184,128 vs 183,300; 94,344 vs 95,936); H5d spill-aware policy reproduces 2/2 measured signs, max advantage error 1.57 pp; superseded occupancy…; next: GPU-adjudicate held-out rectangular shapes to identify the reload law and test the tiling corollary: (K=128,J=32), (K=32,J=128), (K=256,J=40), plus a J-tiled K=J=128 contraction built from J=32 tiles. The rho*K and const reload models predict ~4x different spill traffic at (32,128), so one launch separates them. If the J-tiled variant recovers the amortization win at K=J=128, the wide-shape loss is a scheduling artifact fixable by tiling rather than grounds to decline to amortize.; commit 79af53d2e524fe940e847f277ca2e347555cfd96; PR https://github.com/mrcha033/mlir-fft-compiler/pull/1; GPU handoff 20260720T030001Z-mlir-fft-compiler - multi-lora-fusion [scientific outcome=positive]: When a fused GEMM's cost model has two cache-capacity boundaries defined on nested tensors -- a total-working-set knee and an output-tensor knee -- the boundaries are strictly ordered rather than competing, and the ordering is provable rather than empirical. Because the output tensor Y is contained in the working set, working_set_bytes >= output_bytes per request for every shape, which forces working_set_cap/output_cap <= knee/(usable_fraction*cache). Whenever the fitted knee lies below the usable cache the working-set boundary binds first for ALL shapes, so a min() over the two hard caps is degenerate and the boundaries compose sequentially. The ordering is shape-invariant but the boundari…; validation: Full suite: 627 tests pass (up from 526), stable across 3 consecutive full-suite runs after the flaky-test fix; experiments/resolve_boundary_ordering.py run 3 times; headline numbers reproduce (output step 1.90-2.03x, two-boundary tail error 0.8-1.2% vs single-knee 16.4-17.3%); 900-shape analytic grid: 0 ordering inversions, max continuous cap ratio 0.704 <= analytic bound 0.710; Measured close-shape profile (N=4..256, 25 repeats, median, 1 thread): 1.07x graded rise at working-set cap, 1.98x s…; next: Measure both capacity knees on GPU (L40S). The prior GPU run located only the output knee (Y ~ 0.5*L2); the working-set knee was never measured there. Two sharp questions: (a) does the boundary ordering survive a usable fraction of 0.5, which tightens the bound to knee/(0.5*L2) and inverts iff the working-set knee exceeds half the L2; (b) is the working-set knee graded on GPU as on CPU, or does the launch-bound regime flatten it? Secondary CPU follow-up: characterize what the working-set knee d…; commit 3dd704c833ccf69c1dfc5ba0c1fa2f733d32e94e; PR https://github.com/mrcha033/multi-lora-fusion/pull/1; GPU handoff 20260720T030001Z-multi-lora-fusion - spectral-operator-compiler [scientific outcome=positive]: Two optimizations that each eliminate a disjoint stage of the same operator compose with efficiency (1-f_a)(1-f_b)/(1-f_a-f_b) = 1 + f_a*f_b/(1-f_a-f_b), which is strictly greater than 1 — they super-compose, and the naive multiplicative prediction s_a*s_b is a strict lower bound rather than an estimate. The mechanism is mutual Amdahl masking: measured in isolation, each lever's speedup is capped by the stage the other lever would have removed, so both solo measurements understate the pair, and the shortfall grows with f_a*f_b — i.e. it is worst exactly when both stages are large and the combination is most valuable. Measured on an FNO spectral-conv forward: a weight-layout lowering (1.54-1…; validation: Full test suite: 371 passed (330 prior + 41 new), 1 unrelated PyTorch complex-module warning; All four factorial cells bit-identical at every shape (max_abs_err = 0.0), enforced in-harness by assert_cells_equivalent; benchmarks/bench_lever_composition.py run twice independently; headline structure reproduced (s_both 7.84-8.29x at Cin=512, 4.06-5.05x at Cin=256); ranges reported rather than single figures; Closed form 1 + f_a*f_b/(1-f_a-f_b) verified symbolically via sympy and encoded with tests…; next: Test whether the decayed weight can become a training win rather than an inference-only cache, by folding the decay into the parameter at initialization (store W' = W * decay and train that directly), removing the f_wp stage entirely instead of memoizing it. This is bit-exact in the forward but NOT gradient-equivalent: it rescales each mode's gradient by decay[k], changing the effective per-mode learning rate under any non-scale-invariant optimizer. Falsifiable question: is the training traject…; commit a2a50fb1f14b3cafb34c1d2ac37ffbb8f5eb63f0; PR https://github.com/mrcha033/spectral-operator-compiler/pull/1 - openevolve-moe-prototype [scientific outcome=mixed]: In LLM-driven evolutionary program search, sibling programs sharing a parent agree on outcome far more than unrelated programs from the same task (67.6% vs 38.4% pair concordance), and this clustering is what suppresses DPO-pair yield. The cause is NOT near-duplicate sampling: siblings are measurably more textually similar than unrelated candidates (0.846 vs 0.683, p = 5e-05), yet code similarity does not predict outcome agreement among unrelated pairs at all (rho = +0.019, p = 0.56), and matching controls on similarity absorbs only 1.8% of the sibling excess. Matching instead on the parent's normalized position in the task's score range absorbs 74% (excess +0.290 -> +0.075, n.s.). Decompos…; validation: Full test suite: 441 passed in 27.4s (.venv_test/bin/python -m pytest tests/ -q); 49 new tests in tests/test_sibling_concordance.py, up from 392 total.; Known-answer checks on every statistic: matched_excess recovers a planted +1.0 difference, returns exactly 0.0 under a true null, and its permutation p is <0.01 for the planted effect and >0.2 under the null.; Covariate-confound rejection test: on a pool where siblings and controls differ only in q-stratum, the unmatched estimator reports exces…; next: Test parent-selection directly, since A1g promoted it to the top lever and — unlike A1f's proposed diversity intervention — it is a scheduler change rather than a sampler change, so it can be projected offline first. On the existing committed trees, replay the pilot's actual parent-selection policy against a q-band-targeted alternative (bias selection toward A1f's productive band q in [0.4, 0.6)) and compare predicted conversion under each, using A1g's q-conditional outcome rates rather than th…; commit 11a77d13a64a2b8e5f7955f676071034a4d326a0; PR https://github.com/mrcha033/openevolve-moe-prototype/pull/1
당시 조건	Only completed, evidence-backed research findings are included. Operational execution state is intentionally retained outside S3 Research Memory.
실제 결과	mlir-fft-compiler [scientific outcome=positive]: On GPU lowering of dense complex contractions, register pressure acts as a threshold at the architectural register cap, not as a continuous occupancy penalty. Re-analysis of four L40S (sm_89, complex128) configurations shows achieved occupancy spans only 5.53 pp (14.34-19.87%) and picks the faster lowering at 0 of 2 shapes -- it is anti-correlated with runtime, so an occupancy-knee cost model cannot be rescued by recalibration. The discriminator is spilling past the 255-register cap: below it the Gauss-amortized lowering wins on issue slots alone ((K-1)/(4K), with measured dynamic instructions within 2.5% of the closed forms 3KJ+J and 4KJ); above it, excess registers convert arithmetic savi…; validation: Full suite: 1205 tests pass (105 new in tests/test_spill_model.py), 0 failures; H5b spill predicate agrees with nvcc's static spill bytes at 4/4 measured hardware points, zero fitted parameters; H5c implied reload counts 87.29 (complex_spec) vs 89.16 (real_fold) agree to 2.15% across two different schedules; predicted spill bytes within 1.7% of measured (184,128 vs 183,300; 94,344 vs 95,936); H5d spill-aware policy reproduces 2/2 measured signs, max advantage error 1.57 pp; superseded occupancy…; commit 79af53d2e524fe940e847f277ca2e347555cfd96; PR https://github.com/mrcha033/mlir-fft-compiler/pull/1; GPU handoff 20260720T030001Z-mlir-fft-compiler multi-lora-fusion [scientific outcome=positive]: When a fused GEMM's cost model has two cache-capacity boundaries defined on nested tensors -- a total-working-set knee and an output-tensor knee -- the boundaries are strictly ordered rather than competing, and the ordering is provable rather than empirical. Because the output tensor Y is contained in the working set, working_set_bytes >= output_bytes per request for every shape, which forces working_set_cap/output_cap <= knee/(usable_fraction*cache). Whenever the fitted knee lies below the usable cache the working-set boundary binds first for ALL shapes, so a min() over the two hard caps is degenerate and the boundaries compose sequentially. The ordering is shape-invariant but the boundari…; validation: Full suite: 627 tests pass (up from 526), stable across 3 consecutive full-suite runs after the flaky-test fix; experiments/resolve_boundary_ordering.py run 3 times; headline numbers reproduce (output step 1.90-2.03x, two-boundary tail error 0.8-1.2% vs single-knee 16.4-17.3%); 900-shape analytic grid: 0 ordering inversions, max continuous cap ratio 0.704 <= analytic bound 0.710; Measured close-shape profile (N=4..256, 25 repeats, median, 1 thread): 1.07x graded rise at working-set cap, 1.98x s…; commit 3dd704c833ccf69c1dfc5ba0c1fa2f733d32e94e; PR https://github.com/mrcha033/multi-lora-fusion/pull/1; GPU handoff 20260720T030001Z-multi-lora-fusion spectral-operator-compiler [scientific outcome=positive]: Two optimizations that each eliminate a disjoint stage of the same operator compose with efficiency (1-f_a)(1-f_b)/(1-f_a-f_b) = 1 + f_a*f_b/(1-f_a-f_b), which is strictly greater than 1 — they super-compose, and the naive multiplicative prediction s_a*s_b is a strict lower bound rather than an estimate. The mechanism is mutual Amdahl masking: measured in isolation, each lever's speedup is capped by the stage the other lever would have removed, so both solo measurements understate the pair, and the shortfall grows with f_a*f_b — i.e. it is worst exactly when both stages are large and the combination is most valuable. Measured on an FNO spectral-conv forward: a weight-layout lowering (1.54-1…; validation: Full test suite: 371 passed (330 prior + 41 new), 1 unrelated PyTorch complex-module warning; All four factorial cells bit-identical at every shape (max_abs_err = 0.0), enforced in-harness by assert_cells_equivalent; benchmarks/bench_lever_composition.py run twice independently; headline structure reproduced (s_both 7.84-8.29x at Cin=512, 4.06-5.05x at Cin=256); ranges reported rather than single figures; Closed form 1 + f_a*f_b/(1-f_a-f_b) verified symbolically via sympy and encoded with tests…; commit a2a50fb1f14b3cafb34c1d2ac37ffbb8f5eb63f0; PR https://github.com/mrcha033/spectral-operator-compiler/pull/1 openevolve-moe-prototype [scientific outcome=mixed]: In LLM-driven evolutionary program search, sibling programs sharing a parent agree on outcome far more than unrelated programs from the same task (67.6% vs 38.4% pair concordance), and this clustering is what suppresses DPO-pair yield. The cause is NOT near-duplicate sampling: siblings are measurably more textually similar than unrelated candidates (0.846 vs 0.683, p = 5e-05), yet code similarity does not predict outcome agreement among unrelated pairs at all (rho = +0.019, p = 0.56), and matching controls on similarity absorbs only 1.8% of the sibling excess. Matching instead on the parent's normalized position in the task's score range absorbs 74% (excess +0.290 -> +0.075, n.s.). Decompos…; validation: Full test suite: 441 passed in 27.4s (.venv_test/bin/python -m pytest tests/ -q); 49 new tests in tests/test_sibling_concordance.py, up from 392 total.; Known-answer checks on every statistic: matched_excess recovers a planted +1.0 difference, returns exactly 0.0 under a true null, and its permutation p is <0.01 for the planted effect and >0.2 under the null.; Covariate-confound rejection test: on a pool where siblings and controls differ only in q-stratum, the unmatched estimator reports exces…; commit 11a77d13a64a2b8e5f7955f676071034a4d326a0; PR https://github.com/mrcha033/openevolve-moe-prototype/pull/1
왜 그랬는지	These are evidence-backed scientific outcomes. Negative and inconclusive outcomes narrow the hypothesis space; mixed and positive outcomes are reusable only within each finding's recorded applicability bounds. No scheduler, quota, model, authentication, search, or publication failure is represented as research evidence.
다음에 기억할 것	mlir-fft-compiler: When a register-pressure cost model inverts a hardware sign, check whether the modeled mechanism actually varies across the measured points before recalibrating it -- a quantity with a 5 pp spread that anti-predicts the winner needs replacing, not retuning. For register-limited GPU kernels, model pressure as a threshold at the architectural cap rather than as a continuous occupancy term: below the cap it is free, above it excess registers become memory traffic, which is why such cost models fail by sign flip rather than gradual error. The enabling reduction is that spill traffic can depend on the code variant only through its excess register count, so an expensive schedule-dependent memory term collapses into a closed-form register count the compiler already has -- test this by comparing implied per-slot reload counts across variants. Finally, separate parameter-free claims from fitted ones when hardware points are scarce: a 4-parameter fit to 4 points is a calibration, and only the zero-parameter predicates constitute evidence. multi-lora-fusion: Before building a min()-style selector over two capacity constraints, check whether the quantities they are defined on are nested. If one tensor is contained in the other's byte count, the caps inherit a fixed ordering bounded by the ratio of the two capacity thresholds, and no amount of shape search will produce an inversion -- the search is refutable by algebra in minutes instead of by sweeps. Separately, do not let a proven degeneracy over hard caps silently propagate to tolerance-relaxed or budget-relaxed versions of the same caps: relaxation breaks the containment argument, and the second constraint becomes live exactly in the throughput-oriented regime a real scheduler operates in. Finally, when comparing two numerically equivalent computations that differ by reassociation (e.g. (XB)A vs X(BA)), use a RELATIVE tolerance -- the disagreement scales with output magnitude, so an absolute-only tolerance with unseeded random operands produces tests that fail intermittently on large draws. spectral-operator-compiler: Never rank or triage candidate optimizations by their individually measured speedups when they target different stages of the same operator — solo numbers are mutually Amdahl-masked and systematically under-value combinations, most severely for the highest-value pairs. A lever with an unimpressive solo number may simply be masked by a stage another lever removes. Run the full factorial instead, and bracket the expected result between two nulls: the multiplicative product (provably too weak) and an isolated-stage Amdahl prediction (too strong, because timing stages on pre-materialized operands over-credits the stage speedup that the in-situ forward actually realizes). This directly implicates compiler cost models that score rewrites one at a time. openevolve-moe-prototype: When sibling or group-level outcome clustering appears in an evolutionary or tree-structured search, do not attribute it to sampler diversity before testing whether a shared covariate of the group's root explains it. The decisive test is cheap and needs no new runs: build non-sibling control pairs from the same task, refine matching cells one covariate at a time, and permute the group label within cells. Two diagnostics carry most of the information — whether the suspected carrier (here, code similarity) predicts the outcome in the CONTROL group, and how much of the raw excess each matching layer absorbs. A carrier that correlates with group membership but not with the outcome among controls is a real property of the sampler that is nonetheless causally inert. Equally important: decompose the excess by outcome channel rather than reporting pooled concordance, because a pooled statistic can be dominated by a channel the covariate explains while the channel that actually gates the downstream objective behaves oppositely. Relatedly, an iid baseline built on rates pooled across a heterogeneous population will over-predict and manufacture apparent clustering; condition the baseline on…
언제 맞는지	mlir-fft-compiler: Established for dense all-GENERAL complex128 contractions y = W*x with compile-time constant W, one thread per contraction, on NVIDIA L40S (sm_89, 255-register cap), comparing a four-FMA-chain real lowering against a Gauss 3-multiply lowering with hoisted input sums. The threshold-vs-knee conclusion and the excess-register reduction should generalize to other register-limited straight-line GPU kernels and other NVIDIA architectures sharing the 255-register cap, but the fitted timing coefficients are L40S- and precision-specific. Two boundaries are explicitly unestablished: only square shapes at a single reuse factor K were measured, so the reload law's K-dependence (rho*K vs constant) is unidentified and the models diverge ~4x off the diagonal; and the corollary that tiling J below the spill boundary recovers the amortization win at wide shapes is a prediction of the model, not a measured result. multi-lora-fusion: Established on CPU (AMD Ryzen 9 9950X, 32 MiB usable L3), float32, single LoRA layer, single thread, torch.bmm, for the LoRA shape family X:(n,d), B:(d,r), A:(r,k). The containment argument is hardware- and kernel-independent and should transfer wherever the output tensor is counted inside the working set; the specific bound value is not, since it depends on knee/(usable_fraction*cache). On GPUs where the output tensor claims only a fraction of L2 (~0.5 measured on an L40S) the bound tightens and inversion becomes conceivable, requiring the working-set knee to exceed half the L2 -- untested. The 900-shape grid is analytic cap arithmetic; only two shapes were measured end-to-end. Cap VALUES do not transfer across shapes (knee re-fit at 14.8 MiB vs 22.7 MiB reference), so per-shape calibration is still required even though the ordering result holds universally. spectral-operator-compiler: The closed form holds for any two optimizations that remove disjoint, additively-decomposable stages of a single operator's wall-clock, independent of backend or hardware; it degrades when the levers share a stage or when one lever changes the cost of another's stage. The specific measured speedups are bounded to FNO 1-D spectral convolution forward at inference (eval, no_grad), torch 2.13, CPU, 16 threads, at channel-heavy shapes (Cin >= 256) where both stage fractions are large. At small channels (Cin = 32/64, f_wp ~ 0.02) the cache lever is within run-to-run noise and the efficiency ratio is uninformative. No GPU measurement was performed. openevolve-moe-prototype: Established on 5 working-harness tasks of one LoRA-expert OpenEvolve pilot (~20 candidates per task, 30 pairable families, median children-per-parent k = 2), so magnitudes are pilot-specific and the residual near-miss effect is underpowered — the direction is what holds, not the size. The methodology (matched non-sibling controls, layer-wise covariate stripping, within-cell label permutation, per-channel decomposition, covariate-conditioned iid baselines) generalizes to any tree-structured search where preference pairs are mined from parent-child transitions. One boundary condition is explicit: similarity here is textual (difflib over tokens), so the sampler hypothesis is only ruled out for textual duplication — a sampler emitting semantically equivalent but textually distinct siblings would be scored as diverse and would require an AST-level or semantic proxy to exclude.
신뢰도	중간
관련 자료	Achieved occupancy (sm__warps_active) across all four measured configurations: 14.34/19.87/16.21/15.57%, spread 5.53 pp, correctly ordering the faster lowering at 0/2 shapes; Parameter-free spill predicate 8+2*MAXLIVE > 255 matches nvcc's static spill bytes at 4/4 points (J=32: raw 140/204, 0 spill bytes observed; J=128: raw 524/780, 95,936/183,300 bytes observed); Implied reload counts local_ld/(4*excess): 87.29 (excess 525) vs 89.16 (excess 269), agreeing to 2.15% across two different schedules; predicted spill bytes within 1.7% of measured (184,128 vs 183,300; 94,344 vs 95,936); Advantage at K=J=32 (no-spill): measured +22.65%, spill model +24.22%, occupancy model -55.56%; at K=J=128 (both-spill): measured -22.08%, spill model -21.51%, occupancy model +24.85%; Measured dynamic instructions per problem at K=J=32 (3,180 and 4,172) within 2.5% of closed forms 3KJ+J=3,104 and 4KJ=4,096, confirming the instruction model transfers to hardware in the no-spill regime; Artifacts: src/spill_model.py, experiments/spill_calibration.py, experiments/results/spill_calibration.json, tests/test_spill_model.py (105 tests); full suite 1205 tests passing; mlir-fft-compiler commit 79af53d2e524fe940e847f277ca2e347555cfd96; https://github.com/mrcha033/mlir-fft-compiler/pull/1; 900-shape analytic grid (seq_len 8-256, hidden_dim 16-1024, rank 2-64, out_dim 512-16384): 0 ordering inversions; max continuous cap ratio 0.704 <= analytic bound 0.710 = knee/LLC (22.7 MiB knee, 32 MiB single-CCD L3); Direct measurement at the closest approach the machine admits (n=64,d=64,r=8,k=1024; caps 75 and 127, only 1.69x apart vs 5.68x for the reference shape), N=4..256, 25 repeats, median, single thread: mean us/request 27.56 below both caps, 29.42 between them (1.07x graded rise), 58.39 above both (1.98x sharp step); A 1.2x adjacent-point cliff detector returns None below the output cap despite that window crossing the working-set cap, while the sharpest jump in the full sweep brackets N=124->128 at Y/LLC = 0.97->1.00 -- only the output boundary is a cliff; the working-set boundary is a slope; Two-boundary composed model scores 0.8% mean / 1.8% max relative error on the output tail of a shape it was not fit on, versus 17.3% / 32.1% for a single-knee resident_fraction fit; Tolerance sweep: the relaxed cap crosses the output cap at 11.4% tolerance (output-dominated shape) and 22.9% (reference shape), confirming the scheduler-side min() is not degenerate; Reproduced across three independent runs (output step 1.90-2.03x); 627 tests pass including record-pinning tests over the committed JSON; multi-lora-fusion commit 3dd704c833ccf69c1dfc5ba0c1fa2f733d32e94e; https://github.com/mrcha033/multi-lora-fusion/pull/1; benchmarks/results/lever_composition_cpu.json: 2x2 factorial over 5 FNO shapes; s_both = 4.06-5.05x at Cin=256 and 7.84-8.29x at Cin=512 vs multiplicative nulls 2.60-2.69x and 2.99-3.61x; composition efficiencies 1.56-1.87 and 2.29-2.63 (two independent runs, torch 2.13 CPU, 16 threads); src/lever_composition.py: ideal_disjoint_efficiency encodes the closed form; amdahl_composition_prediction gives the a-priori stage-model null computed from the baseline profile without using the combined measurement; tests/test_lever_composition.py: 41 tests including strict-super-composition across a fraction grid, agreement with the closed form, and consistency with composing the two individual Amdahl speedups; closed form independently verified symbolically; All four factorial cells bit-identical at every shape (max_abs_err = 0.0) via assert_cells_equivalent, so the speedups are schedule changes rather than approximations; Full suite 371 passed (330 prior + 41 new); spectral-operator-compiler commit a2a50fb1f14b3cafb34c1d2ac37ffbb8f5eb63f0; https://github.com/mrcha033/spectral-operator-compiler/pull/1; src/sibling_concordance.py: matched-control sibling-excess estimator over 931 within-task child pairs (71 sibling, 860 non-sibling controls) from 5 working-harness pilot tasks, with cells refined one covariate at a time and a within-cell label-permutation test (20,000 permutations); reports/phase_a1g_sibling_concordance_report.md/.json: matching layers task_only +0.290 (p = 5e-05), similarity +0.285 (p = 1e-04), parent_quality +0.075 (p = 0.16), similarity_and_quality +0.078 (p = 0.16); Outcome-channel decomposition: both-positive raw excess +0.219 -> +0.023 quality-matched (89.5% absorbed); both-near-miss +0.084 -> +0.070 (16.3% absorbed); Family-level reshuffle with and without a quality stratum: 30 families, 5 observed converting, expected 11.81 (p = 0.0005) unstratified vs 9.35 (p = 0.0070) quality-stratified; tests/test_sibling_concordance.py: 49 tests (441 total, all passing), including a pure-covariate-confound case where the naive estimator reports excess > 0.7 and the matched estimator must report 0.0, its complement preserving a genuine within-stratum effect, and reconciliation of task set, family count, conversion count and sibling-pair count with the prior phase; openevolve-moe-prototype commit 11a77d13a64a2b8e5f7955f676071034a4d326a0; https://github.com/mrcha033/openevolve-moe-prototype/pull/1
자료 출처	우리 기록
작성자	S3ResearchAgent
처음 작성한 시각 (UTC)	2026-07-20T04:31:39.031776Z
마지막 수정 시각 (UTC)	2026-07-20T04:31:39.659083Z

근거 research-artifact-a1e681c9013372a5: Achieved occupancy (sm__warps_active) across all four measured configurations: 14.34/19.87/16.21/15.57%, spread 5.53 pp, correctly ordering the faster lowering at 0/2 shapes

벤치마크 · 확인 범위: 일부 자료 확인 · S3ResearchAgent · 2026-07-20T04:31:39.031776Z

근거 commit_79af53d2e524fe94: GitHub mrcha033/mlir-fft-compiler commit 79af53d2e524fe940e847f277ca2e347555cfd96 (원문 열기)
코드 · 확인 범위: 일부 자료 확인 · S3ResearchAgent · 2026-07-20T04:31:39.260525Z
Commit emitted by this cycle; validation scope is recorded in the Lesson.

근거 commit_3dd704c833ccf69c: GitHub mrcha033/multi-lora-fusion commit 3dd704c833ccf69c1dfc5ba0c1fa2f733d32e94e (원문 열기)
코드 · 확인 범위: 일부 자료 확인 · S3ResearchAgent · 2026-07-20T04:31:39.415099Z
Commit emitted by this cycle; validation scope is recorded in the Lesson.

근거 commit_a2a50fb1f14b3caf: GitHub mrcha033/spectral-operator-compiler commit a2a50fb1f14b3cafb34c1d2ac37ffbb8f5eb63f0 (원문 열기)
코드 · 확인 범위: 일부 자료 확인 · S3ResearchAgent · 2026-07-20T04:31:39.497103Z
Commit emitted by this cycle; validation scope is recorded in the Lesson.

근거 commit_11a77d13a64a2b8e: GitHub mrcha033/openevolve-moe-prototype commit 11a77d13a64a2b8e5f7955f676071034a4d326a0 (원문 열기)
코드 · 확인 범위: 일부 자료 확인 · S3ResearchAgent · 2026-07-20T04:31:39.659083Z
Commit emitted by this cycle; validation scope is recorded in the Lesson.