Bind H2-P ShapeNet training, first-epoch gate and paired scoring for review

This commit is contained in:
NewMeltAssist committed 2026-11-19 18:12:25 +08:00
1 parent db87b0f54b
commit 70a85dffb8
10 files changed
+7577

No files matched your search

@@ -0,0 +1,972 @@
{
"handoff": "h-b5985d03",
"identity": "H2-P",
"seeds": [
0,
1,
2
],
"train_cases": [
1,
2,
4,
5,
6,
7,
8,
10,
12,
13,
17,
18,
21,
22,
23,
25,
26,
27,
28,
29,
30,
31,
32,
34,
35,
39,
40,
43,
44,
45,
46,
47,
48,
49,
50,
51,
52,
54,
55,
56,
58,
59,
60,
61,
62,
63,
64,
65,
67,
69,
70,
71,
72,
73,
74,
75,
76,
77,
78,
79,
80,
81,
83,
84,
85,
86,
87,
88,
90,
91,
92,
94,
95,
96,
97,
100,
101,
102,
105,
106,
107,
109,
110,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
121,
123,
124,
125,
126,
127,
128,
129,
130,
131,
133,
134,
136,
137,
138,
139,
140,
141,
142,
143,
144,
145,
146,
147,
148,
149,
150,
151,
152,
153,
155,
156,
157,
158,
159,
160,
161,
162,
163,
165,
166,
170,
172,
173,
175,
176,
177,
178,
179,
180,
181,
182,
183,
184,
186,
190,
191,
192,
193,
195,
196,
198,
199,
200,
201,
202,
203,
205,
207,
210,
211,
212,
213,
214,
215,
217,
219,
220,
221,
222,
223,
224,
225,
227,
228,
229,
230,
231,
232,
233,
234,
235,
236,
237,
241,
243,
244,
245,
246,
247,
248,
249,
251,
252,
253,
255,
257,
258,
259,
260,
261,
262,
263,
264,
266,
267,
268,
269,
271,
272,
273,
274,
275,
276,
277,
278,
279,
280,
281,
282,
283,
285,
286,
289,
290,
291,
292,
293,
294,
295,
296,
297,
298,
299,
300,
301,
302,
304,
305,
306,
308,
309,
310,
311,
312,
313,
314,
315,
319,
320,
321,
322,
323,
324,
325,
327,
328,
329,
331,
332,
333,
334,
335,
337,
338,
339,
340,
341,
344,
345,
347,
348,
349,
350,
352,
353,
354,
355,
356,
357,
358,
360,
362,
364,
365,
366,
367,
369,
371,
372,
373,
374,
375,
376,
378,
379,
380,
381,
384,
385,
389,
392,
393,
397,
398,
399,
401,
402,
403,
404,
405,
407,
408,
410,
412,
413,
414,
415,
417,
418,
419,
420,
422,
424,
425,
427,
430,
431,
433,
435,
436,
437,
439,
440,
443,
444,
446,
447,
448,
449,
450,
451,
452,
453,
454,
455,
456,
457,
459,
460,
462,
463,
464,
465,
466,
467,
468,
469,
470,
472,
473,
474,
475,
476,
478,
479,
480,
482,
483,
486,
487,
488,
490,
493,
494,
495,
496,
497,
498,
499,
501,
502,
503,
504,
505,
507,
508,
509,
511,
512,
513,
514,
515,
516,
518,
519,
521,
522,
523,
524,
525,
527,
529,
530,
532,
533,
536,
538,
539,
540,
542,
543,
545,
547,
548,
549,
550,
551,
552,
553,
554,
555,
560,
561,
562,
564,
565,
566,
567,
568,
569,
572,
573,
574,
576,
577,
579,
581,
582,
583,
584,
587,
588,
589,
591,
593,
594,
595,
596,
597,
598,
600,
602,
604,
608,
610,
611,
612,
613,
615,
616,
617,
618,
620,
621,
622,
623,
625,
626,
627,
628,
629,
630,
631,
632,
633,
634,
635,
636,
638,
639,
640,
641,
642,
643,
644,
645,
646,
647,
648,
649,
651,
652,
654,
655,
656,
657
],
"heldout_cases": [
658,
659,
660,
662,
663,
664,
665,
666,
667,
668,
672,
673,
674,
675,
676,
677,
678,
679,
681,
683,
684,
686,
687,
688,
689,
690,
691,
692,
693,
695,
696,
697,
700,
701,
702,
703,
704,
705,
708,
709,
710,
711,
712,
713,
715,
717,
718,
719,
721,
722,
723,
724,
725,
726,
727,
729,
730,
731,
733,
734,
735,
736,
737,
738,
739,
740,
741,
743,
744,
745,
746,
747,
748,
749,
750,
751,
752,
753,
757,
758,
760,
762,
763,
764,
765,
766,
767,
768,
769,
770,
771,
772,
773,
775,
776,
777,
778,
779,
781,
782,
783,
784,
785,
787,
789,
790,
791,
792,
793,
795,
797
],
"pressure_selection": "original raw rows [0:16] and [112:] in original vertex order",
"metric": "per-case L2(predicted minus true decoded pressure) / L2(true decoded pressure)",
"summary": "equal cases, then equal matched seeds",
"component_definition": "exact source triangle-mesh SHA-256, geometry-only; no known family identifiers",
"heldout_components": [
[
658
],
[
659
],
[
660
],
[
662
],
[
663
],
[
664
],
[
665
],
[
666
],
[
667
],
[
668
],
[
672
],
[
673
],
[
674
],
[
675
],
[
676
],
[
677
],
[
678
],
[
679
],
[
681
],
[
683
],
[
684
],
[
686
],
[
687
],
[
688
],
[
689
],
[
690
],
[
691
],
[
692
],
[
693
],
[
695
],
[
696
],
[
697
],
[
700
],
[
701
],
[
702
],
[
703
],
[
704
],
[
705
],
[
708
],
[
709
],
[
710
],
[
711
],
[
712
],
[
713
],
[
715
],
[
717
],
[
718
],
[
719
],
[
721
],
[
722
],
[
723
],
[
724
],
[
725
],
[
726
],
[
727
],
[
729
],
[
730
],
[
731
],
[
733
],
[
734
],
[
735
],
[
736
],
[
737
],
[
738
],
[
739
],
[
740
],
[
741
],
[
743
],
[
744
],
[
745
],
[
746
],
[
747
],
[
748
],
[
749
],
[
750
],
[
751
],
[
752
],
[
753
],
[
757
],
[
758
],
[
760
],
[
762
],
[
763
],
[
764
],
[
765
],
[
766
],
[
767
],
[
768
],
[
769
],
[
770
],
[
771
],
[
772
],
[
773
],
[
775
],
[
776
],
[
777
],
[
778
],
[
779
],
[
781
],
[
782
],
[
783
],
[
784
],
[
785
],
[
787
],
[
789
],
[
790
],
[
791
],
[
792
],
[
793
],
[
795
],
[
797
]
],
"bootstrap": {
"replicates": 2000,
"seed": 20261119,
"confidence": 0.95,
"method": "paired component resampling with replacement; case weighted; all three paired seeds retained"
},
"paired_delta": "H2-P minus GINO in percentage points",
"gate": "all three exact seed pairs valid, GINO reproduction mean in [6.62,7.62], paired CI high < 0",
"no_test_selection": true
}
@@ -0,0 +1,814 @@
{
"paper_data": {
"path": "/home/frank14f/optane/MeltMind/data/track-b-gino-shapenet611-2026-11-19/paper-car-pressure-data.zip",
"sha256": "b5f9e2b407d54e034596384253fb58196933c46f6b5b586383508da54475f89d"
},
"paper_supplement": {
"path": "/home/frank14f/optane/MeltMind/data/track-b-gino-shapenet611-2026-11-19/paper-neurips-supplement.zip",
"sha256": "48cdae80ac2781e27ac00e10a37124711d6bb305593559002bda0527d11a533d"
},
"paper_code_zip_sha256": "347a6f097e2b9958d1ab87930fa1d6227b793a9d213e12418ce9a157e83dce04",
"paper_compatibility": {
"handoff": "h-b8508140",
"identity": "supplement code + 2-keyword patch",
"patch_path": "/home/frank14f/optane/MeltMind/artifacts/track-b-paper-keyword-compatibility-2026-11-19/two-keyword-patch.json",
"patch_sha256": "7307ba49f83bfc46c5decf803a993a41ed602d987de65714958e738d2f52f077",
"search_path": "/home/frank14f/optane/MeltMind/artifacts/track-b-paper-keyword-compatibility-2026-11-19/keyword-search.json",
"search_sha256": "77a897bf534a9a0e9e6a7c072b4f914168648eadc2af3493b70d63d0b715b3d0"
},
"split": {
"train": [
1,
2,
4,
5,
6,
7,
8,
10,
12,
13,
17,
18,
21,
22,
23,
25,
26,
27,
28,
29,
30,
31,
32,
34,
35,
39,
40,
43,
44,
45,
46,
47,
48,
49,
50,
51,
52,
54,
55,
56,
58,
59,
60,
61,
62,
63,
64,
65,
67,
69,
70,
71,
72,
73,
74,
75,
76,
77,
78,
79,
80,
81,
83,
84,
85,
86,
87,
88,
90,
91,
92,
94,
95,
96,
97,
100,
101,
102,
105,
106,
107,
109,
110,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
121,
123,
124,
125,
126,
127,
128,
129,
130,
131,
133,
134,
136,
137,
138,
139,
140,
141,
142,
143,
144,
145,
146,
147,
148,
149,
150,
151,
152,
153,
155,
156,
157,
158,
159,
160,
161,
162,
163,
165,
166,
170,
172,
173,
175,
176,
177,
178,
179,
180,
181,
182,
183,
184,
186,
190,
191,
192,
193,
195,
196,
198,
199,
200,
201,
202,
203,
205,
207,
210,
211,
212,
213,
214,
215,
217,
219,
220,
221,
222,
223,
224,
225,
227,
228,
229,
230,
231,
232,
233,
234,
235,
236,
237,
241,
243,
244,
245,
246,
247,
248,
249,
251,
252,
253,
255,
257,
258,
259,
260,
261,
262,
263,
264,
266,
267,
268,
269,
271,
272,
273,
274,
275,
276,
277,
278,
279,
280,
281,
282,
283,
285,
286,
289,
290,
291,
292,
293,
294,
295,
296,
297,
298,
299,
300,
301,
302,
304,
305,
306,
308,
309,
310,
311,
312,
313,
314,
315,
319,
320,
321,
322,
323,
324,
325,
327,
328,
329,
331,
332,
333,
334,
335,
337,
338,
339,
340,
341,
344,
345,
347,
348,
349,
350,
352,
353,
354,
355,
356,
357,
358,
360,
362,
364,
365,
366,
367,
369,
371,
372,
373,
374,
375,
376,
378,
379,
380,
381,
384,
385,
389,
392,
393,
397,
398,
399,
401,
402,
403,
404,
405,
407,
408,
410,
412,
413,
414,
415,
417,
418,
419,
420,
422,
424,
425,
427,
430,
431,
433,
435,
436,
437,
439,
440,
443,
444,
446,
447,
448,
449,
450,
451,
452,
453,
454,
455,
456,
457,
459,
460,
462,
463,
464,
465,
466,
467,
468,
469,
470,
472,
473,
474,
475,
476,
478,
479,
480,
482,
483,
486,
487,
488,
490,
493,
494,
495,
496,
497,
498,
499,
501,
502,
503,
504,
505,
507,
508,
509,
511,
512,
513,
514,
515,
516,
518,
519,
521,
522,
523,
524,
525,
527,
529,
530,
532,
533,
536,
538,
539,
540,
542,
543,
545,
547,
548,
549,
550,
551,
552,
553,
554,
555,
560,
561,
562,
564,
565,
566,
567,
568,
569,
572,
573,
574,
576,
577,
579,
581,
582,
583,
584,
587,
588,
589,
591,
593,
594,
595,
596,
597,
598,
600,
602,
604,
608,
610,
611,
612,
613,
615,
616,
617,
618,
620,
621,
622,
623,
625,
626,
627,
628,
629,
630,
631,
632,
633,
634,
635,
636,
638,
639,
640,
641,
642,
643,
644,
645,
646,
647,
648,
649,
651,
652,
654,
655,
656,
657
],
"test": [
658,
659,
660,
662,
663,
664,
665,
666,
667,
668,
672,
673,
674,
675,
676,
677,
678,
679,
681,
683,
684,
686,
687,
688,
689,
690,
691,
692,
693,
695,
696,
697,
700,
701,
702,
703,
704,
705,
708,
709,
710,
711,
712,
713,
715,
717,
718,
719,
721,
722,
723,
724,
725,
726,
727,
729,
730,
731,
733,
734,
735,
736,
737,
738,
739,
740,
741,
743,
744,
745,
746,
747,
748,
749,
750,
751,
752,
753,
757,
758,
760,
762,
763,
764,
765,
766,
767,
768,
769,
770,
771,
772,
773,
775,
776,
777,
778,
779,
781,
782,
783,
784,
785,
787,
789,
790,
791,
792,
793,
795,
797
],
"raw_global_bounds": [
[
-0.90252799,
0.0066688,
-2.85272002
],
[
0.90253001,
1.95825005,
2.86385012
]
]
},
"split_receipt": {
"path": "/home/frank14f/optane/MeltMind/artifacts/track-b-gino-shapenet611-2026-11-19/paper-split.json",
"sha256": "5a96c25c2ec24cfc1e2264d4ebd0879c658c0f168e22711b576bf303151b8601"
},
"mapping_audit": {
"path": "/home/frank14f/optane/MeltMind/artifacts/track-b-gino-shapenet611-2026-11-19/paper-mapping-audit.json",
"sha256": "055d008a02494acd29df36c41c8e68db931a027f5635e8f5f765a96a54c62289"
},
"protocol": {
"model": "NeurIPS 2023 supplement SDFFNOGNO decoder",
"seeds": [
0,
1,
2
],
"grid": [
64,
64,
64
],
"modes": [
24,
24,
24
],
"hidden_channels": 32,
"radius": 0.05,
"epochs_per_seed": 100,
"batch_size": 1,
"learning_rate": 0.001,
"bounds_expansion": 0.01,
"pressure_epsilon": 1e-06,
"optimizer": "Adam",
"weight_decay": 0.0001,
"lr_step_epochs": 50,
"lr_gamma": 0.5,
"pressure_training_transform": "scalar Gaussian on the 500 learning cases",
"metric": "per-case L2(predicted minus true decoded pressure) / L2(true decoded pressure)",
"report": "equal mean over 111 cases for each seed, then equal mean over the three seeds",
"acceptance_percent": [
6.62,
7.62
],
"paper_reference_percent": 7.12,
"checkpoint_epoch": 100,
"heldout_access_after_all_checkpoints_frozen": true
},
"environment": {
"python": "/home/frank14f/optane/MeltMind/data/track-b-gino-shapenet611-2026-11-19/runtime/bin/python",
"python_version": "3.10",
"torch_cuda": "11.6",
"neuralop_commit": "fbdc7f872792b75b84545c2f374e7a881c72a718",
"neuralop_file_sha256": {
"utils.py": "84554eed45ac415ab52f79e456eab70ba204e7ab7539c2f2841955a9145220b4",
"models/__init__.py": "c67679f1f8f90e1ab4eb4c2aa916aeaedf1b175d795fed03b8d4f7210883ebae",
"models/tfno.py": "d74b5805b69a64bf33e3ff5186709c75bd431a56c9548f06fb9635a859d849e4",
"models/spectral_convolution.py": "ccecf80806d93e8f35713ac6ab2c3b61c11739f5fcb8c0ba7397b7d4eb5a5d45"
},
"package_versions": {
"torch": "1.13.1+cu116",
"open3d": "0.17.0",
"numpy": "1.24.3",
"torch-scatter": "2.1.1+pt113cu116",
"torch-sparse": "0.6.17+pt113cu116",
"torch-geometric": "2.3.1",
"tensorly": "0.8.1",
"tensorly-torch": "0.4.0"
}
},
"environment_ruling": "h-0d21f3bd",
"environment_acceptance": {
"path": "/home/frank14f/optane/MeltMind/artifacts/track-b-gino-shapenet611-import-checked-2026-11-19/cpu-environment-acceptance.json",
"sha256": "093e646890929af6f520eb5eecf8c751025c0a24b8b5689094b1a0ae4da08dc3"
},
"limits": {
"cleanup_seconds": 20,
"idle_wait_seconds": 60,
"rss_bytes": 12884901888,
"recorded_vram_bytes": 15032385536,
"device_vram_bytes": 16106127360,
"disk_bytes": 2147483648,
"torch_threads": 1,
"max_processes": 1,
"cpu_seconds_per_gpu_second": 8
},
"code_sha256": {
"/home/frank14f/optane/MeltMind/tools/freeze_g1_components.py": "d0cee60d95243ac2c59ef3f2244ba818315718c4e3d1895f2f9f064f1f7f5ecd",
"/home/frank14f/optane/MeltMind/tools/gre24_models.py": "53b6fee8b700b9b982b06d29908ce2ce23e0c57512c46dbf74b2aade79e3ac3a",
"/home/frank14f/optane/MeltMind/tools/phase2_gate_outcome_review.py": "915617aeb8292d03c654e637bc34a014c254fd178a773f135d1806c4b41372a8",
"/home/frank14f/optane/MeltMind/tools/phase2_h1_worker_v2.py": "1543df85b615bb69b79bacd572074a7c77ae19dab110197601573a7e5805ed20",
"/home/frank14f/optane/MeltMind/tools/phase2_home_freeze_io.py": "bf09204b85ed2a7038acdd202257f618474d1110a9d6d772f105a3ffb334d3ff",
"/home/frank14f/optane/MeltMind/tools/phase2_local_freeze_io.py": "60adf3382577613c5234f5cf30779336b9951b66e90c075cb7cd0adab9cc42dd",
"/home/frank14f/optane/MeltMind/tools/phase2_residual_math.py": "ffbd9624dec79bdaabf95244fe87209055908f31a977e73ea4377045d6f8fe62",
"/home/frank14f/optane/MeltMind/tools/phase3_item1b_common.py": "4e25effe8326ff8c7c3f751590315040209af054b32b0505dc3c6b001589db32",
"/home/frank14f/optane/MeltMind/tools/phase3_seed1_v2_common.py": "25ca6be14027369393bd3616209b08f30e25892cccca83300483c5a116e8d75d",
"/home/frank14f/optane/MeltMind/tools/phase3_shared_capacity.py": "7c07b0aaf1bc4e6a980d016defcac326c3bd871134d2583bb4dcd88bb34728f8",
"/home/frank14f/optane/MeltMind/tools/prepare_track_b_gino_shapenet.py": "557ad56277d7e85c6b5cc358eb151632d1757f5883f429988d36022d0d407550",
"/home/frank14f/optane/MeltMind/tools/s2_gpu_idle_gate.py": "e2b1613e7e6ea398a8d555220a9365a1ad998ab4ef4b2bf8ec7cc4e31f8b4b9f",
"/home/frank14f/optane/MeltMind/tools/s2_main_memory_guard.py": "e094f5443e11518efe9018215c11718a8e18aa462a977bf43e974b2d0b2aebb1",
"/home/frank14f/optane/MeltMind/tools/s2_pilot_train.py": "e9cceead51a5cc092aad23409ad98909c84a62e7e10571e750d1e9be1ad3b948",
"/home/frank14f/optane/MeltMind/tools/s2_precision_continuation_guard.py": "01235d897c7c03e5ffa109c58b14f5d24d128e8f1ba873e1f76cfb14e02f7a7f",
"/home/frank14f/optane/MeltMind/tools/s2_recovery_gpu_supervisor.py": "689c0f3179e4fcd362e546d90214829a9e4f8739abdbdf74b560763e5a392f15",
"/home/frank14f/optane/MeltMind/tools/s2_recovery_monitoring.py": "442c2a9c75e8c00b30a8f2e91cb52d87c466b19a80aea9128b10c021e61b922e",
"/home/frank14f/optane/MeltMind/tools/track_a_h2_common.py": "79918e7de887d1f0a2de5523156b27d00dc2d85ac930a07efc34d817d904fe65",
"/home/frank14f/optane/MeltMind/tools/track_a_h2_prepare.py": "f657be036dc48fc5936f56c4b8510a4b295d4787af6877cc5ccaad663107be17",
"/home/frank14f/optane/MeltMind/tools/track_b_gino_shapenet_entry.py": "e86d955c36e291e6bbef67947de663b24c8d66c5d72d9d28e4193fb8a3051ee2",
"/home/frank14f/optane/MeltMind/tools/track_b_gino_shapenet_worker.py": "7211be211c29472fd9be35a6bcb1f56025de4a63f36852bfafa10df97c003ff3",
"/home/frank14f/optane/MeltMind/tools/track_b_gino_import_checked_entry.py": "199d833f40339feb0433611ba27302416a280452f8918715e6ef95cb93c38721",
"/home/frank14f/optane/MeltMind/tools/track_b_gino_import_checked_worker.py": "3acf742dd4549e9f5491e10af5bb0b4acf00e2f47e91753100b5998cfcc61852",
"/home/frank14f/optane/MeltMind/tools/prepare_track_b_gino_import_checked.py": "fef485dd0c233c76a336239d5f29cbf44ac0fb62a6a297dff34293b23a1b75fe",
"/home/frank14f/optane/MeltMind/tools/track_b_gino_paper_keyword_patch.py": "c61e2ed7d099eb125386857bf4d7ccdbfc3af522f80edb4f01b450cee91c0b95",
"/home/frank14f/optane/MeltMind/tools/track_b_gino_measurement_gpu2.py": "7d3ab2412e5208892cffcfc0e1ec363eb5db2be3e10bf60595356f71e82d8552",
"/home/frank14f/optane/MeltMind/tools/track_b_gino_measurement_gpu2_worker.py": "ba1fd5ec837e884b000ba640fceafe30ea40ccf708847733df6a17a8f3599680",
"/home/frank14f/optane/MeltMind/tools/track_b_gino_ordinal_recovery.py": "1e1827498afab62e2f28efb5d450376f2dca4e8bf6f74114f2914ec771872c86",
"/home/frank14f/optane/MeltMind/tools/track_b_gino_ordinal_recovery_worker.py": "7a68c77e9c913ba9161832f513dbf8754ebc5c270c1e742fa5ae97a7b14b9120",
"/home/frank14f/optane/MeltMind/tools/track_b_gino_formal.py": "aa7b1301203d433564491b72fc967a29898098ad8d0d3677cda88991fbc7b483",
"/home/frank14f/optane/MeltMind/tools/track_b_gino_formal_guard.py": "70820fb9208960485efe07654057977b676a3003563b6a54cf00c86dc838613d",
"/home/frank14f/optane/MeltMind/tools/track_b_gino_formal_worker.py": "978f1c7cfb622300b8814e14e4a02e5cbb9e2ea7f6e5fee080b986c7409ade2c",
"/home/frank14f/optane/MeltMind/tools/track_b_h2_pressure_entry.py": "8023bba517ad9ea0d3be0d819c1c0040def215bbac4d4c6bc248a83a4d970a4f",
"/home/frank14f/optane/MeltMind/tools/track_b_h2_pressure_worker.py": "69b2517d42adc7196f41b3975997e88bc65a0fb5d109bbdb31b9c354ff73e797",
"/home/frank14f/optane/MeltMind/tools/track_b_h2_pressure_prepare.py": "1f3673fe3afbdf0b9fe948c55e8017a93a55673ec96def3359f144f4a60b11c5",
"/home/frank14f/optane/MeltMind/tools/phase2_h2_model.py": "fab2470dd0654ca74c3b7d893f35ad1f3ae6c5c08ffe334ef6312cf6ec87892a"
},
"mode": "h2-pressure-combined",
"identity": "H2-P",
"handoff": "h-b5985d03",
"reference": {
"path": "/home/frank14f/optane/MeltMind/artifacts/track-b-gino-shapenet611-formal-v3-2026-11-19/contract.json",
"sha256": "c3c5c5f0fab049c757032c343673104eb0f99cbaead5e0f78247f2a3aa6173c3",
"comparison_sha256": "503f6c8ab1217d66b44e0d127555cfad5da4cd8a17b336299095c3cfd13041d7"
},
"geometry_audit": {
"path": "/home/frank14f/optane/MeltMind/artifacts/track-b-h2-pressure-combined-2026-11-19/geometry-audit.json",
"sha256": "d50f37226b64f6d8317a64a93819a20883ae31762fa2f40d6944a7913394e224"
},
"comparison_contract": "/home/frank14f/optane/MeltMind/artifacts/track-b-h2-pressure-combined-2026-11-19/comparison-contract.json",
"comparison_contract_sha256": "e6995675276c4a647e349ca5d0f34c05c47957871b91a5ae98f685ec93a3b62f",
"devices": {
"0": "GPU-e8853ae7-a302-6a17-bcfa-aa767e9ed20c",
"1": "GPU-f1c9fd5a-e917-56e0-21fb-24035ba44a36",
"2": "GPU-b8c11c01-c91f-aa0b-abf6-dad35085cc76"
},
"first_epoch_seed": 0,
"total_gpu_seconds": 40000,
"scoring_seconds_per_seed": 300,
"timing_margin": 1.25,
"future_fit_setup_floor_seconds": 120,
"gpu3_eligible": false,
"model": {
"inputs": [
"x",
"y",
"z"
],
"edges": "original triangle edges both directions",
"mass": "one-third incident area",
"message_components": "surface edge connectivity",
"architecture": "shared four 64-wide H2 blocks and direct pressure head",
"optimizer_and_case_loss": "same Adam, StepLR and LpLoss as fixed GINO training body"
},
"custody": {
"train_reads_per_seed": 500,
"heldout_reads_per_seed": 111,
"require_all_frozen_checkpoints": true,
"retries": 0
}
}
@@ -0,0 +1,67 @@
{
"status": "PASS",
"tests": 9,
"actual_gpu_queries": 0,
"actual_pressure_members_opened": 0,
"actual_target_reads": 0,
"scenarios": {
"ok": {
"combined": "COMPLETE",
"trigger": null,
"actual_cpu_children": 6,
"phase_order": [
[
0,
"fit"
],
[
1,
"fit"
],
[
2,
"fit"
],
[
0,
"score"
],
[
1,
"score"
],
[
2,
"score"
]
],
"stage_terminals": [
"COMPLETE",
"COMPLETE",
"COMPLETE",
"COMPLETE",
"COMPLETE",
"COMPLETE"
]
},
"over": {
"combined": "STOPPED",
"trigger": "STOP_PROJECTED_CAP",
"actual_cpu_children": 1,
"phase_order": [],
"stage_terminals": [
"STOPPED"
]
},
"busy": {
"combined": "STOPPED",
"trigger": "Seed 0 fit HOLD: IDLE_DEADLINE",
"actual_cpu_children": 0,
"phase_order": [],
"stage_terminals": [
"STOPPED"
]
}
},
"replay_log_sha256": "2bb37bc6eab7069ce0e67a64d526d15a57f037834f91891aea929d78d48246d8"
}
@@ -0,0 +1,14 @@
test_actual_guard_and_combined_order (test_track_b_h2_pressure_combined.CombinedGuard) ... ok
test_actual_sequential_guard_stops_after_cost_failure (test_track_b_h2_pressure_combined.CombinedGuard) ... ok
test_busy_after_initial_admission_starts_no_worker (test_track_b_h2_pressure_combined.CombinedGuard) ... ok
test_missing_independent_review_refuses_before_device_probe (test_track_b_h2_pressure_combined.CombinedGuard) ... ok
test_first_epoch_at_two_sides_of_cap (test_track_b_h2_pressure_combined.PressureWork) ... ok
test_h2_model_forward_and_backward_on_original_runtime (test_track_b_h2_pressure_combined.PressureWork) ... ok
test_paired_components_bootstrap_and_gino_gate (test_track_b_h2_pressure_combined.PressureWork) ... ok
test_production_fit_callback_raises_on_first_full_epoch (test_track_b_h2_pressure_combined.PressureWork) ... ok
test_real_score_wrap_requires_custody_and_reads_only_once (test_track_b_h2_pressure_combined.PressureWork) ... ok
----------------------------------------------------------------------
Ran 9 tests in 2.031s
OK
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,11 @@
# H2-P ShapeNet611 训练和评分联合预审
H2-P 使用一个入口按种子 0、1、2 串行训练,每个种子固定 100 轮。GPU0、GPU1、GPU2 按序尝试空闲准入,GPU3 不参与此入口。每步复用修正后的实际守卫,核验连续三次空闲、临派复查、worker 物理卡见证和现有资源上限。完成独立预审仍需匹配实际阶段及用卡授权。此交付止于准备与 CPU 回放。 [Claude 裁定 h-b5985d03](https://arcticnimbus.slack.com/archives/C0C78UFKGRM/p1795077393513799) · [联合合同](../artifacts/track-b-h2-pressure-combined-2026-11-19/contract.json)
与 GINO 比较固定原始 500/111 划分,使用原始 PLY 顺序和原 3,586 点压力映射。H2-P 以同一坐标归一化、原三角形双向边和每个入射面的三分之一面积为输入,经共用四层 H2 块输出逐点压力。压力归一化仅在 500 件学习集拟合,训练沿用基线 Adam、StepLR 和逐件 LpLoss。几何验收只打开 611 个 PLY 成员,全部可构图,压力成员读取为零。 [几何回执](../artifacts/track-b-h2-pressure-combined-2026-11-19/geometry-audit.json)
正式总帽为 40,000 GPU 秒。种子 0 的首个完整 500 件轮是实际计时,该轮计入最终 100 轮。首轮门计入已耗时间,以实测轮时和 25% 余量投影余下 299 轮,并计入后两个种子的准备、三个评分段各 300 秒和收尾预留。在首轮估算超帽就停在第一轮。各阶段实际等待、设置、训练、评分和失败都走同一个总时钟,零重试。 [入口及成本门](../tools/track_b_h2_pressure_entry.py)
三份第 100 轮检查点均由守卫接受并按 SHA-256 封存后,每个种子在独占留出日志下按原顺序读取一次 111 个压力目标。报告列出全部三个种子的状态与有效成绩。比较使用解码压力逐件相对 L2,配对量是 H2-P 减 GINO 的百分点差。固定 2,000 次配对组件 bootstrap、95% 区间、种子 20261119。组件由原始网格字节哈希固定,留出集为 111 个单件组件,当前资料没有家族谱系。保留三对种子的共同重采样。只有三对均有效、GINO 通过原 6.62%–7.62% 复现门、且配对区间上界严格小于零,才支持这个协议下的改善。 [预登记比较](../artifacts/track-b-h2-pressure-combined-2026-11-19/comparison-contract.json)
九项 CPU 检查通过。冻结合同原件经生产入口和守卫回放了三次训练后才进入三次评分、忙卡零派发以及首轮超帽后停止。另验无独立审阅时不探查卡、H2-P 合成前后向、检查点门、同一种子第二次留出读取拒绝及配对判决。首次回放的两项失败来自夹具传入空序号,改用合成序号后重验通过。实际 GPU、训练、评分及压力目标读取均为零。 [CPU 回放](../artifacts/track-b-h2-pressure-combined-2026-11-19/cpu-replay.json) · [回放用例](../tests/test_track_b_h2_pressure_combined.py)
+214
View File
@@ -0,0 +1,214 @@
"""CPU-only checks of the combined production entry, timing and custody bindings."""
from pathlib import Path
from tempfile import TemporaryDirectory
from types import SimpleNamespace
import time
import unittest
from unittest.mock import patch
import numpy as np
import torch
from s2_gpu_idle_gate import wait_idle
import track_b_gino_formal_guard as real_guard
import track_b_h2_pressure_entry as entry
from track_b_h2_pressure_prepare import surface
import track_b_h2_pressure_worker as worker
from track_b_gino_shapenet_entry import read, save, sha
EVIDENCE = {}
class CombinedGuard(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.binding = entry.contract()
cls.contract_bytes = (entry.ROOT / 'contract.json').read_bytes()
def replay(self, mode):
with TemporaryDirectory() as folder:
root = Path(folder)
(root / 'contract.json').write_bytes(self.contract_bytes)
fixture = root / 'track_b_h2_pressure_worker.py'
fixture.write_text(
'import json, pathlib, sys\n'
'seed, phase = sys.argv[1:]\n'
'root = pathlib.Path(__file__).parent / f"seed-{seed}" / phase\n'
'records = root / "worker-records"\n'
'records.mkdir()\n'
f'if {mode == "over"}:\n'
' (root / "first-epoch-projection.json").write_text('
'json.dumps({"within_cap":False}))\n'
' raise SystemExit(2)\n'
'path = records / "result.json"\n'
'temp = path.with_suffix(".tmp")\n'
'temp.write_text(json.dumps(dict(peak_allocated_bytes=1, peak_reserved_bytes=2)))\n'
'temp.rename(path)\n')
admission = []
clock = [0.]
selected = entry.DEVICES['0']
def probe(uuid):
self.assertEqual(uuid, selected)
admission.append(uuid)
return dict(uuid=uuid, idle=True, unix=10., occupants=[], memory_MiB=0)
def sample(uuid):
return dict(probe(uuid), idle=mode != 'busy')
def cpu_wait(uuid, limit, record, *, sample):
return wait_idle(uuid, limit, record, sample=sample, clock=lambda: clock[0],
sleep=lambda seconds: clock.__setitem__(0, clock[0] + seconds))
builds = []
author = dict(eligible_ordinals=['0'], dispatch_before_unix=time.time()+60)
def capture_result(c, seed, phase):
builds.append((seed, phase))
return sha(entry.run_root(seed, phase) / 'worker-records/result.json')
def fake_roster(_):
self.assertEqual(builds, [(s, 'fit') for s in entry.SEEDS])
return {str(seed): {'synthetic': True} for seed in entry.SEEDS}
with (patch.object(entry, 'ROOT', root), patch.object(entry, 'SOURCES', root),
patch.object(entry, 'authorize', return_value=author),
patch.object(entry, 'snapshot', side_effect=probe),
patch.object(entry, 'validate_result', side_effect=capture_result),
patch.object(entry, 'all_checkpoints', side_effect=fake_roster),
patch.object(real_guard, 'snapshot', side_effect=sample),
patch.object(real_guard, 'wait_idle', side_effect=cpu_wait),
patch.object(real_guard, 'dispatch_environment',
side_effect=lambda _, env: (dict(env, CUDA_VISIBLE_DEVICES='0'), []))):
code = entry.run(self.binding)
with self.assertRaises(FileExistsError):
entry.run(self.binding)
stages = sorted(root.glob('seed-*/*/complete.json'))
terminals = [read(p) for p in stages]
starts = len(list(root.glob('seed-*/*/actual-worker-spawn.json')))
e = read(root / 'complete.json')
if mode == 'ok':
self.assertEqual((code, e['status'], starts), (0, 'COMPLETE', 6), e)
self.assertEqual(builds, [(s, phase) for phase in ('fit', 'score') for s in entry.SEEDS])
self.assertTrue(all(x['lifecycle'][0]['event'] == 'leader_reaped' for x in terminals))
else:
expected = 'STOP_PROJECTED_CAP' if mode == 'over' else 'Seed 0 fit HOLD: IDLE_DEADLINE'
self.assertEqual((code, e['trigger'], starts), (1, expected, int(mode == 'over')))
self.assertEqual(len(stages), 1)
self.assertFalse((root / 'checkpoints-frozen.json').exists())
EVIDENCE[mode] = dict(combined=e['status'], trigger=e['trigger'], actual_cpu_children=starts,
phase_order=builds, stage_terminals=[x['status'] for x in terminals])
def test_actual_guard_and_combined_order(self):
self.replay('ok')
def test_busy_after_initial_admission_starts_no_worker(self):
self.replay('busy')
def test_actual_sequential_guard_stops_after_cost_failure(self):
self.replay('over')
def test_missing_independent_review_refuses_before_device_probe(self):
with patch.object(entry, 'snapshot') as probe:
with self.assertRaises(FileNotFoundError):
entry.run(self.binding)
probe.assert_not_called()
class PressureWork(unittest.TestCase):
def test_first_epoch_at_two_sides_of_cap(self):
row = dict(stage='EPOCH_COMPLETE', seed=0, epoch=1, examples=500, seconds=90.)
ticket = dict(guard_started_monotonic=100.)
low = entry.first_epoch_projection(ticket, row, 220.)
self.assertTrue(low['within_cap'])
self.assertEqual(low['booked_seconds_so_far'], 120)
self.assertEqual(low['remaining_train_epochs'], 299)
row['seconds'] = 115.
high = entry.first_epoch_projection(ticket, row, 245.)
self.assertFalse(high['within_cap'])
with self.assertRaises(ValueError):
entry.first_epoch_projection(ticket, dict(row, examples=499), 245.)
def test_production_fit_callback_raises_on_first_full_epoch(self):
def fixture_train(c, data, seed, epochs, path):
save(path, dict(stage='EPOCH_COMPLETE', seed=seed, epoch=1, examples=500, seconds=120.))
raise AssertionError('Second epoch should never be entered')
with TemporaryDirectory() as folder, patch.object(worker, 'train_seed', fixture_train):
root = Path(folder)
data = SimpleNamespace(train_ids=[1], data=lambda *_: [1])
with self.assertRaisesRegex(RuntimeError, 'STOP_PROJECTED_CAP'):
worker.fit({'protocol': {'epochs_per_seed': 100}}, 0, data, root, root,
{'guard_started_monotonic': time.monotonic() - 140})
self.assertFalse(read(root/'first-epoch-projection.json')['within_cap'])
self.assertFalse((root/'epoch-100.pt').exists())
def test_h2_model_forward_and_backward_on_original_runtime(self):
torch.set_num_threads(1)
x = np.array([[0., 0., 0.], [1., 0., 0.], [0., 1., 0.], [0., 0., 1.]])
triangles = np.array([[0,1,2], [0,2,3], [1,2,3], [0,1,3]])
graph = surface(x, triangles, [-1]*3, [2]*3)
model = worker.PressureModel().train()
item = dict(graph=[a[None] for a in graph], pressure=torch.tensor([[1., 2., 3., 4.]]))
loss = model.loss_dict(item, torch.nn.functional.mse_loss)['loss']
self.assertTrue(bool(torch.isfinite(loss)))
loss.backward()
self.assertTrue(bool(torch.any(model.head[-1].weight.grad != 0)))
def test_real_score_wrap_requires_custody_and_reads_only_once(self):
with TemporaryDirectory() as folder:
root = Path(folder)
path = root/'epoch-100.pt'
torch.save(dict(state={}, pressure_mean=torch.tensor([2.]), pressure_std=torch.tensor([3.])), path)
roster = {'0': dict(checkpoint=dict(path=str(path), sha256=sha(path)))}
save(root/'checkpoints-frozen.json', roster)
c = dict(protocol={'pressure_epsilon': 1e-6})
seen = []
def load(ids, role, f):
self.assertEqual(role, 'heldout')
for case in ids:
seen.append(case)
f.write(str(case) + '\n')
return object()
ids = list(range(111))
data = SimpleNamespace(test_ids=ids, normalizer_class=type('Normalizer', (), {}), data=load)
model = SimpleNamespace(load_state_dict=lambda *_a, **_kw: None, to=lambda _: model)
scored = [dict(case=case, relative_l2=.07) for case in ids]
with patch.object(entry, 'all_checkpoints', side_effect=PermissionError('unfrozen')):
with self.assertRaises(PermissionError):
worker.score(c, 0, data, root)
self.assertEqual(seen, [])
with (patch.object(entry, 'all_checkpoints', return_value=roster),
patch.object(worker, 'paper_model', return_value=model),
patch.object(worker.gino, 'case_scores', return_value=scored),
patch.object(torch.cuda, 'synchronize')):
result = worker.score(c, 0, data, root)
with self.assertRaises(FileExistsError):
worker.score(c, 0, data, root)
self.assertEqual(seen, ids)
self.assertEqual(result['target_reads'], 111)
def test_paired_components_bootstrap_and_gino_gate(self):
ids = list(range(111))
c = dict(heldout_cases=ids, heldout_components=[ids[:2]]+[[i] for i in ids[2:]])
def arms(error):
return [[dict(case=i, relative_l2=error) for i in ids] for _ in entry.SEEDS]
stats = entry.paired_bootstrap(c, arms(.06), arms(.07))
self.assertAlmostEqual(stats['paired_mean_difference_pp'], -1.)
self.assertEqual(stats['decision'], 'H2_P_IMPROVEMENT_PASS')
self.assertEqual(entry.paired_bootstrap(c, arms(.07), arms(.07))['decision'],
'H2_P_IMPROVEMENT_NOT_ESTABLISHED')
self.assertEqual(entry.paired_bootstrap(c, arms(.06), arms(.08))['decision'],
'GINO_REPRODUCTION_GATE_NOT_MET')
with self.assertRaises(ValueError):
entry.paired_bootstrap(c, arms(.06)[:2], arms(.07))
if __name__ == '__main__':
unittest.main()
@@ -0,0 +1,54 @@
"""Freeze H2-P comparison metadata and audit only original triangle mesh members."""
from pathlib import Path
from tempfile import TemporaryDirectory
from zipfile import ZipFile
import torch
import track_b_h2_pressure_entry as entry
from track_b_gino_paper_keyword_patch import extract_patched_paper_code
from track_b_gino_shapenet_entry import read, save
from track_b_h2_pressure_worker import SurfaceData, mesh_graph
def prepare():
c = entry.reference.contract()
entry.ROOT.mkdir(exist_ok=False)
torch.set_num_threads(1)
with TemporaryDirectory(prefix='h2-p-mesh-only-') as folder:
extract_patched_paper_code(c, folder)
path = Path(folder)
data = SurfaceData(c, path)
rows = []
class MeshOnly:
def __init__(self, archive):
self.archive = archive
def read(self, member):
if not member.startswith('car-pressure-data/data/mesh_') or not member.endswith('.ply'):
raise PermissionError('Preparation may only open original meshes')
return self.archive.read(member)
with ZipFile(c['paper_data']['path']) as archive:
for case in data.train_ids + data.test_ids:
graph, faces = mesh_graph(c, path, MeshOnly(archive), data.rows[case], data.paper)
x, mass, receivers, _, _, components = graph
rows.append(dict(case=case, vertices=len(x), faces=faces,
edge_count=len(receivers), components=int(components.max()) + 1,
total_positive_area=float(mass.double().sum())))
save(entry.ROOT/'geometry-audit.json', dict(status='PASS', mesh_members_opened=len(rows),
target_members_opened=0, actual_gpu_queries=0, rows=rows))
save(entry.ROOT/'comparison-contract.json', entry.expected_comparison(c))
save(entry.ROOT/'contract.json', entry.expected_contract())
assert entry.contract()['identity'] == 'H2-P'
print(f'{len(rows)} original shape meshes audited, zero pressure members')
if __name__ == '__main__':
import os
if os.environ.get('CUDA_VISIBLE_DEVICES') != '':
raise PermissionError('Preparation is CPU only')
prepare()
+346
View File
@@ -0,0 +1,346 @@
"""One reviewed, cost-gated H2-P pipeline with frozen three-seed custody."""
import argparse
from collections import defaultdict
import fcntl
import json
import math
from pathlib import Path
import signal
import time
from phase2_gate_outcome_review import validate_review
from s2_gpu_idle_gate import snapshot
import track_b_gino_formal as reference
from track_b_gino_formal_guard import guard
from track_b_gino_shapenet_entry import BASE, checked, read, save, sha
ROOT = BASE / 'artifacts/track-b-h2-pressure-combined-2026-11-19'
REFERENCE_SHA = 'c3c5c5f0fab049c757032c343673104eb0f99cbaead5e0f78247f2a3aa6173c3'
DEVICES = {'0': reference.DEVICES['2'], '1': 'GPU-f1c9fd5a-e917-56e0-21fb-24035ba44a36',
'2': reference.DEVICES['0']}
SEEDS = (0, 1, 2)
CAP = 40000
SCORE_RESERVE = 300
BOOTSTRAP_REPS = 2000
BOOTSTRAP_SEED = 20261119
SOURCES = Path(__file__).resolve().parent
def geometry_components(c):
mapping = read(c['mapping_audit']['path'])['rows']
by_case = {row['case']: row['mesh_sha256'] for row in mapping}
if set(by_case) != set(c['split']['train'] + c['split']['test']):
raise ValueError('Mesh identity roster differs')
if {by_case[i] for i in c['split']['train']} & {by_case[i] for i in c['split']['test']}:
raise ValueError('Identical raw mesh would cross the fixed learning and held-out split')
groups = defaultdict(list)
for case in c['split']['test']:
groups[by_case[case]].append(case)
return list(groups.values())
def expected_comparison(c):
return dict(handoff='h-b5985d03', identity='H2-P', seeds=list(SEEDS),
train_cases=c['split']['train'], heldout_cases=c['split']['test'],
pressure_selection='original raw rows [0:16] and [112:] in original vertex order',
metric=c['protocol']['metric'], summary='equal cases, then equal matched seeds',
component_definition='exact source triangle-mesh SHA-256, geometry-only; no known family identifiers',
heldout_components=geometry_components(c),
bootstrap=dict(replicates=BOOTSTRAP_REPS, seed=BOOTSTRAP_SEED, confidence=.95,
method='paired component resampling with replacement; case weighted; all three paired seeds retained'),
paired_delta='H2-P minus GINO in percentage points',
gate='all three exact seed pairs valid, GINO reproduction mean in [6.62,7.62], paired CI high < 0',
no_test_selection=True)
def expected_contract():
base = reference.contract()
base_path = checked(reference.ROOT / 'contract.json', REFERENCE_SHA)
ref = dict(path=str(base_path), sha256=REFERENCE_SHA,
comparison_sha256=base['comparison_contract_sha256'])
geometry = ROOT / 'geometry-audit.json'
audit = read(geometry)
if (audit['status'] != 'PASS' or audit['mesh_members_opened'] != 611 or audit['target_members_opened'] != 0
or [r['case'] for r in audit['rows']] != base['split']['train'] + base['split']['test']):
raise ValueError('Complete geometry-only coverage is required')
comparison = ROOT / 'comparison-contract.json'
if read(comparison) != expected_comparison(base):
raise ValueError('Pre-registered comparison differs')
c = {key: base[key] for key in (
'paper_data', 'paper_supplement', 'paper_code_zip_sha256', 'paper_compatibility',
'split', 'split_receipt', 'mapping_audit', 'protocol', 'environment', 'environment_ruling',
'environment_acceptance', 'limits', 'code_sha256')}
c['code_sha256'].update({str(SOURCES / name): sha(SOURCES / name) for name in (
'track_b_h2_pressure_entry.py', 'track_b_h2_pressure_worker.py',
'track_b_h2_pressure_prepare.py', 'phase2_h2_model.py')})
c.update(mode='h2-pressure-combined', identity='H2-P', handoff='h-b5985d03', reference=ref,
geometry_audit=dict(path=str(geometry), sha256=sha(geometry)),
comparison_contract=str(comparison), comparison_contract_sha256=sha(comparison),
devices=DEVICES, first_epoch_seed=0, total_gpu_seconds=CAP, scoring_seconds_per_seed=SCORE_RESERVE,
timing_margin=1.25, future_fit_setup_floor_seconds=120, gpu3_eligible=False,
model=dict(inputs=['x','y','z'], edges='original triangle edges both directions',
mass='one-third incident area', message_components='surface edge connectivity',
architecture='shared four 64-wide H2 blocks and direct pressure head',
optimizer_and_case_loss='same Adam, StepLR and LpLoss as fixed GINO training body'),
custody=dict(train_reads_per_seed=500, heldout_reads_per_seed=111,
require_all_frozen_checkpoints=True, retries=0))
return c
def contract():
c = read(ROOT / 'contract.json')
if c != expected_contract():
raise PermissionError('H2-P contract or source binding changed')
for path, digest in c['code_sha256'].items():
checked(path, digest)
return c
def authorize(c):
review = validate_review(ROOT)
auth = read(ROOT / 'stage-authorization.json')
approved = auth.get('eligible_ordinals')
expires = auth.get('dispatch_before_unix')
if ((auth['decision'], auth['mode'], auth['contract_sha256'], auth['review_sha256']) !=
('APPROVED', c['mode'], sha(ROOT / 'contract.json'), sha(ROOT / 'review.json'))
or review['verdict'] != 'PASS'
or not isinstance(approved, list) or not approved or len(set(approved)) != len(approved)
or not set(approved) <= set(DEVICES)
or type(expires) not in (float, int) or not math.isfinite(expires)):
raise PermissionError('Exact independent PASS and stage/card authorization required')
return auth
def first_epoch_projection(ticket, progress, now):
if tuple(progress[k] for k in ('stage', 'seed', 'epoch', 'examples')) != ('EPOCH_COMPLETE', 0, 1, 500):
raise ValueError('Only seed 0 first complete 500-case epoch measures cost')
epoch = progress['seconds']
spent = now - ticket['guard_started_monotonic']
setup = spent - epoch
if not math.isfinite(epoch) or not math.isfinite(setup) or epoch <= 0 or setup < 0:
raise ValueError('First full epoch and setup clock differ')
future_setup = max(120, math.ceil(1.25 * setup))
remaining = math.ceil(299 * epoch * 1.25) + 2 * future_setup + 3 * SCORE_RESERVE + 60
projected = spent + remaining
return dict(seed=0, epoch=1, examples=500, epoch_seconds=epoch, booked_seconds_so_far=spent,
measured_setup_seconds=setup, future_fit_setup_reserve_seconds=2 * future_setup,
remaining_train_epochs=299, safety_factor=1.25, scoring_reserve_seconds=3 * SCORE_RESERVE,
fit_cleanup_reserve_seconds=60, projected_total_gpu_seconds=projected,
formal_cap_gpu_seconds=CAP, within_cap=projected <= CAP)
def run_root(seed, phase):
return ROOT / f'seed-{seed}' / phase
score_mean = reference.score_mean
def validate_result(c, seed, phase):
root = run_root(seed, phase)
path = root / 'worker-records/result.json'
result = read(path)
ticket = read(root / 'started.json')
ordinal, uuid = ticket['ordinal'], ticket['physical_uuid']
spawn = read(root / 'actual-worker-spawn.json')
if (DEVICES[ordinal] != uuid or spawn['physical_uuid'] != uuid or spawn['ordinal'] != ordinal
or read(root / 'worker-device-verified.json') !=
dict(process=spawn['process'], physical_uuid=uuid, ordinal=ordinal, observed_uuids=[uuid])):
raise ValueError('Actual H2-P worker/device witness differs')
if (result['status'], result['seed'], result['phase']) != ('COMPLETE', seed, phase):
raise ValueError('Worker result identity differs')
if phase == 'fit':
reference.epoch100(root, seed, c)
checkpoint = result['checkpoint']
if (checkpoint['path'] != str(root / 'epoch-100.pt')
or (result['epochs'], result['training_examples'], result['target_reads']) != (100, 500, 0)
or (root / 'heldout-target-access.jsonl').exists()):
raise ValueError('Fit checkpoint or held-out seal differs')
checked(checkpoint['path'], checkpoint['sha256'])
if seed == 0 and read(root / 'first-epoch-projection.json')['within_cap'] is not True:
raise ValueError('Missing first epoch cost PASS')
else:
manifest = root / 'checkpoints-frozen.json'
roster = all_checkpoints(c)
access = root / 'heldout-target-access.jsonl'
mapping = {row['case']: row['pressure_sha256'] for row in read(c['mapping_audit']['path'])['rows']}
rows = [json.loads(line) for line in access.read_text().splitlines()]
expected = [dict(case=i, role='heldout', sha256=mapping[i]) for i in c['split']['test']]
if (read(manifest) != roster or result['checkpoints_manifest_sha256'] != sha(manifest)
or result['checkpoint_sha256'] != roster[str(seed)]['checkpoint']['sha256']
or result['target_reads'] != 111 or result['target_access_sha256'] != sha(access)
or rows != expected or score_mean(result['cases'], c['split']['test']) != result['mean_percent']):
raise ValueError('Held-out custody or score differs')
return sha(path)
def accepted_terminal(c, seed, phase):
root = run_root(seed, phase)
terminal = read(root / 'complete.json')
if (terminal['status'], terminal['seed'], terminal['phase'], terminal['contract_sha256']) != (
'COMPLETE', seed, phase, sha(ROOT / 'contract.json')):
raise PermissionError('No exact accepted stage terminal')
if (terminal['booked_gpu_cap_exceeded'] or terminal['charged_gpu_seconds'] > terminal['booked_gpu_seconds']
or terminal['result_sha256'] != validate_result(c, seed, phase)):
raise ValueError('H2-P terminal budget or result differs')
return terminal
def all_checkpoints(c):
roster = {}
for seed in SEEDS:
terminal = accepted_terminal(c, seed, 'fit')
root = run_root(seed, 'fit')
result = read(root / 'worker-records/result.json')
roster[str(seed)] = dict(checkpoint=result['checkpoint'], terminal_sha256=sha(root / 'complete.json'),
result_sha256=terminal['result_sha256'])
return roster
def run_stage(c, seed, phase, ordinal, auth, began, deadline, roster=None):
root = run_root(seed, phase)
root.mkdir(parents=True, exist_ok=False)
if phase == 'score':
save(root / 'checkpoints-frozen.json', roster)
uuid = DEVICES[ordinal]
ticket = dict(seed=seed, phase=phase, ordinal=ordinal, physical_uuid=uuid, unix=time.time(),
contract_sha256=sha(ROOT / 'contract.json'), dispatch_before_unix=auth['dispatch_before_unix'],
guard_started_monotonic=began, booked_deadline_monotonic=deadline,
booked_gpu_seconds=deadline - began)
save(root / 'started.json', ticket)
command = [c['environment']['python'], '-B', str(SOURCES / 'track_b_h2_pressure_worker.py'), str(seed), phase]
limits = dict(c['limits'], cpu_seconds=8 * (deadline - began))
return guard(root, command, uuid=uuid, limits=limits, deadline=deadline, ticket=ticket,
validate_result=lambda: validate_result(c, seed, phase))
def run(c):
auth = authorize(c)
with (ROOT / 'combined.lock').open('a') as lock:
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
if (ROOT / 'started.json').exists() or any(ROOT.glob('seed-*')):
raise FileExistsError('H2-P combined attempt already exists')
if time.time() >= auth['dispatch_before_unix']:
raise PermissionError('Card reservation for new dispatch has expired')
ordinal = next((i for i, uuid in DEVICES.items()
if i in auth['eligible_ordinals'] and snapshot(uuid)['idle']), None)
if ordinal is None:
raise RuntimeError('NO_IDLE_APPROVED_GPU0_TO_2')
began = time.monotonic()
deadline = began + CAP
save(ROOT / 'started.json', dict(ordinal=ordinal, physical_uuid=DEVICES[ordinal],
started_monotonic=began, contract_sha256=sha(ROOT / 'contract.json'), phase_budget=CAP))
def request_stop(number, _frame):
raise KeyboardInterrupt(signal.Signals(number).name)
old = signal.signal(signal.SIGTERM, request_stop)
status, trigger = 'STOPPED', None
try:
fit_deadline = deadline - len(SEEDS) * SCORE_RESERVE
for seed in SEEDS:
epoch_start = began if seed == 0 else time.monotonic()
if epoch_start >= fit_deadline:
raise RuntimeError('INSUFFICIENT_FIT_BUDGET')
receipt = run_stage(c, seed, 'fit', ordinal, auth, epoch_start, fit_deadline)
if receipt['status'] != 'COMPLETE':
cost = run_root(0, 'fit') / 'first-epoch-projection.json'
if seed == 0 and cost.exists() and read(cost)['within_cap'] is False:
raise RuntimeError('STOP_PROJECTED_CAP')
raise RuntimeError(f"Seed {seed} fit HOLD: {receipt['trigger']}")
roster = all_checkpoints(c)
save(ROOT / 'checkpoints-frozen.json', roster)
for seed in SEEDS:
score_start = time.monotonic()
score_deadline = min(deadline, score_start + SCORE_RESERVE)
if score_deadline - score_start <= c['limits']['cleanup_seconds']:
raise RuntimeError('INSUFFICIENT_SCORE_BUDGET')
receipt = run_stage(c, seed, 'score', ordinal, auth, score_start, score_deadline, roster)
if receipt['status'] != 'COMPLETE':
raise RuntimeError(f"Seed {seed} score HOLD: {receipt['trigger']}")
status = 'COMPLETE'
except (Exception, KeyboardInterrupt) as exc:
trigger = str(exc) or type(exc).__name__
finally:
signal.signal(signal.SIGTERM, old)
charged = time.monotonic() - began
if charged > CAP and status == 'COMPLETE':
status, trigger = 'STOPPED', 'GPU_BUDGET_OVERAGE'
save(ROOT / 'complete.json', dict(status=status, trigger=trigger, charged_gpu_seconds=charged,
cap_gpu_seconds=CAP, no_retry=True))
return 0 if status == 'COMPLETE' else 1
def paired_bootstrap(comparison, h2, gino):
import numpy as np
ids = comparison['heldout_cases']
groups = comparison['heldout_components']
if sorted(case for group in groups for case in group) != sorted(ids) or min(map(len, groups)) < 1:
raise ValueError('Fixed paired test component support differs')
if len(h2) != 3 or len(gino) != 3:
raise ValueError('All three exact matched seeds are required')
h2_means = [score_mean(rows, ids) for rows in h2]
gino_means = [score_mean(rows, ids) for rows in gino]
deltas = np.array([[a['relative_l2'] - b['relative_l2'] for a, b in zip(hr, gr)]
for hr, gr in zip(h2, gino)], dtype=np.float64).mean(axis=0)
per_case = dict(zip(ids, deltas))
masses = np.array([len(group) for group in groups])
sums = np.array([sum(per_case[case] for case in group) for group in groups])
drawn = np.random.default_rng(BOOTSTRAP_SEED).integers(len(groups), size=(BOOTSTRAP_REPS, len(groups)))
sampled = 100 * sums[drawn].sum(axis=1) / masses[drawn].sum(axis=1)
low, high = map(float, np.quantile(sampled, [.025, .975]))
reference_mean, within = reference.pool(gino_means, [6.62, 7.62])
return dict(h2_percent_by_seed=dict(zip(SEEDS, h2_means)), gino_percent_by_seed=dict(zip(SEEDS, gino_means)),
gino_mean_percent=reference_mean, gino_reproduction_pass=within,
paired_mean_difference_pp=float(100 * deltas.mean()), paired_ci95_pp=[low, high],
components=len(groups), decision=('GINO_REPRODUCTION_GATE_NOT_MET' if not within else
'H2_P_IMPROVEMENT_PASS' if high < 0 else 'H2_P_IMPROVEMENT_NOT_ESTABLISHED'))
def collect(c):
seeds, scores = {}, []
for seed in SEEDS:
rows = {}
for phase in ('fit', 'score'):
root = run_root(seed, phase)
if (root / 'complete.json').exists():
terminal = read(root / 'complete.json')
rows[phase] = dict(status=terminal['status'], trigger=terminal['trigger'])
if phase == 'score' and terminal['status'] == 'COMPLETE':
accepted_terminal(c, seed, phase)
result = read(root / 'worker-records/result.json')
rows['mean_percent'] = result['mean_percent']
scores.append(result['cases'])
else:
rows[phase] = dict(status='UNSETTLED' if (root / 'started.json').exists() else 'NOT_STARTED')
seeds[str(seed)] = rows
report = dict(identity='H2-P', seeds=seeds, paired_status='PENDING_ALL_ACCEPTED_SEEDS')
if len(scores) != 3 or not (ROOT / 'complete.json').exists() or read(ROOT / 'complete.json')['status'] != 'COMPLETE':
return report
gino = reference.contract()
validate_review(reference.ROOT)
refs = []
for seed in SEEDS:
path = reference.run_root(seed, 'score')
terminal = path / 'complete.json'
if not terminal.exists():
return report
if read(terminal)['status'] != 'COMPLETE':
return dict(report, paired_status='GINO_SEED_SCORE_UNAVAILABLE')
reference.accepted_terminal(gino, seed, 'score')
refs.append(read(path / 'worker-records/result.json')['cases'])
stats = paired_bootstrap(read(c['comparison_contract']), scores, refs)
return dict(report, paired_status=stats['decision'], comparison=stats)
if __name__ == '__main__':
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('action', choices=('run', 'collect'))
args = parser.parse_args()
c = contract()
if args.action == 'run':
raise SystemExit(run(c))
print(json.dumps(collect(c), indent=2, allow_nan=False))
+189
View File
@@ -0,0 +1,189 @@
"""H2-P worker using the original ShapeNet case-level training and scoring protocol."""
import argparse
import ctypes
from hashlib import sha256
import io
import json
import os
from pathlib import Path
import signal
import sys
from tempfile import TemporaryDirectory
import time
from types import FunctionType, SimpleNamespace
from zipfile import ZipFile
import numpy as np
import torch
import track_b_gino_formal_worker as gino
import track_b_h2_pressure_entry as entry
from track_b_h2_pressure_prepare import PressureH2, surface
from track_b_gino_paper_keyword_patch import extract_patched_paper_code
from track_b_gino_shapenet_entry import checked, process_identity, read, save, sha
from track_b_gino_shapenet_worker import cuda_peaks, test_environment, train_seed
def mesh_graph(c, folder, archive, row, paper):
case = row['case']
member = archive.read(f'car-pressure-data/data/mesh_{case:03d}.ply')
if sha256(member).hexdigest() != row['mesh_sha256']:
raise ValueError(f'Original mesh hash differs for case {case}')
path = folder / f'mesh_{case:03d}.ply'
path.write_bytes(member)
try:
mesh = paper.load_mesh(path)
xyz = mesh.vertex.positions.numpy()
faces = mesh.triangle.indices.numpy()
finally:
path.unlink()
if len(xyz) != row['mesh_vertices'] or len(xyz) != 3586:
raise ValueError(f'Original vertex support differs for case {case}')
lower, upper = c['split']['raw_global_bounds']
margin = c['protocol']['bounds_expansion']
lo, hi = [v - margin for v in lower], [v + margin for v in upper]
graph = list(surface(xyz, faces, lo, hi))
graph[0] = paper.location_normalization(
torch.as_tensor(xyz, dtype=torch.float32),
torch.tensor(lo, dtype=torch.float32), torch.tensor(hi, dtype=torch.float32),
)
return tuple(graph), len(faces)
class SurfaceData:
def __init__(self, c, folder):
from neuralop.utils import UnitGaussianNormalizer
from src.data.cfd_datamodule import CFDSDFDataModule
self.c = c
self.folder = folder
self.paper = object.__new__(CFDSDFDataModule)
self.normalizer_class = UnitGaussianNormalizer
self.normalizer = None
self.train_ids = c['split']['train']
self.test_ids = c['split']['test']
self.rows = {r['case']: r for r in read(c['mapping_audit']['path'])['rows']}
def data(self, ids, role, target_log=None):
if role == 'train':
allowed = ids == self.train_ids and self.normalizer is None and target_log is None
else:
allowed = role == 'heldout' and ids == self.test_ids and self.normalizer is not None and target_log is not None
if not allowed:
raise PermissionError('Unexpected ShapeNet input or target scope')
graphs, pressures = [], []
folder = self.folder / role
folder.mkdir(exist_ok=False)
with ZipFile(self.c['paper_data']['path']) as archive:
for case in ids:
row = self.rows[case]
graph, _ = mesh_graph(self.c, folder, archive, row, self.paper)
graphs.append(graph)
if role == 'heldout':
target_log.write(json.dumps(dict(case=case, role=role, sha256=row['pressure_sha256'])) + '\n')
target_log.flush()
blob = archive.read(f'car-pressure-data/data/press_{case:03d}.npy')
if sha256(blob).hexdigest() != row['pressure_sha256']:
raise ValueError(f'Original pressure hash differs for case {case}')
raw = np.load(io.BytesIO(blob), allow_pickle=False).reshape(-1).astype(np.float32)
retained = np.concatenate((raw[:16], raw[112:]))
if (raw.size != 3682 or retained.size != 3586 or not np.isfinite(retained).all()
or sha256(retained.tobytes()).hexdigest() != row['retained_pressure_f32_sha256']):
raise ValueError(f'Original pressure mapping differs for case {case}')
pressures.append(torch.from_numpy(retained))
target = torch.stack(pressures)
if role == 'train':
self.normalizer = self.normalizer_class(
target, eps=self.c['protocol']['pressure_epsilon'], reduce_dim=[0, 1], verbose=False)
target = self.normalizer.encode(target)
return [dict(graph=graph, pressure=values) for graph, values in zip(graphs, target)]
class PressureModel(PressureH2):
def data_dict_to_input(self, item):
device = self.encoder[0].weight.device
return tuple(value[0].to(device) for value in item['graph']), None
def forward(self, graph, _unused=None):
return super().forward(*graph)
def loss_dict(self, item, loss_fn):
graph, _ = self.data_dict_to_input(item)
prediction = self(graph).reshape(1, -1)
truth = item['pressure'].to(prediction.device).reshape(1, -1)
return dict(loss=loss_fn(prediction, truth))
def paper_model(_c):
return PressureModel()
def attach(c, root, seed, phase):
ticket = read(root / 'dispatch.json')
owner = os.getppid()
if (ticket['coordinator'] != process_identity(owner)
or ticket['contract_sha256'] != sha(entry.ROOT / 'contract.json')
or (ticket['seed'], ticket['phase']) != (seed, phase)
or time.monotonic() >= ticket['start_by_monotonic']
or str(Path(sys.executable).absolute()) != c['environment']['python']):
raise PermissionError('Worker is not the exact admitted child')
if ctypes.CDLL(None, use_errno=True).prctl(1, signal.SIGKILL, 0, 0, 0) or os.getppid() != owner:
raise RuntimeError('Could not bind worker lifetime to the supervisor')
authorization = entry.authorize(c)
if (entry.DEVICES.get(ticket['ordinal']) != ticket['physical_uuid']
or ticket['ordinal'] not in authorization['eligible_ordinals']):
raise PermissionError('Unapproved physical V100')
return ticket
def fit(c, seed, data, root, records, ticket):
def progress(path, row):
save(path, row)
if seed == 0 and row['epoch'] == 1:
result = entry.first_epoch_projection(ticket, row, time.monotonic())
save(root / 'first-epoch-projection.json', result)
if not result['within_cap']:
raise RuntimeError('STOP_PROJECTED_CAP')
trainer = FunctionType(train_seed.__code__, dict(train_seed.__globals__, paper_model=paper_model,
save=progress), train_seed.__name__)
fit_from_gino = FunctionType(gino.train.__code__, dict(gino.train.__globals__, train_seed=trainer),
gino.train.__name__)
return fit_from_gino(c, seed, data, root, records, torch)
def score(c, seed, data, root):
scorer = FunctionType(gino.score.__code__,
dict(gino.score.__globals__, formal=entry, paper_model=paper_model), gino.score.__name__)
return scorer(c, seed, data, root, torch)
def run(seed, phase):
c = entry.contract()
root = entry.run_root(seed, phase)
ticket = attach(c, root, seed, phase)
test_environment(c)
torch.set_num_threads(c['limits']['torch_threads'])
torch.set_num_interop_threads(1)
binder = FunctionType(gino.bind_device.__code__, dict(gino.bind_device.__globals__,
formal=SimpleNamespace(DEVICES={str(seed): ticket['physical_uuid']})), gino.bind_device.__name__)
binder(root, c, ticket, torch)
torch.cuda.reset_peak_memory_stats()
torch.backends.cuda.matmul.allow_tf32 = False
torch.backends.cudnn.allow_tf32 = False
records = root / 'worker-records'
records.mkdir(exist_ok=False)
with TemporaryDirectory(prefix='h2-pressure-', dir=root) as work:
extract_patched_paper_code(c, work)
data = SurfaceData(c, Path(work))
result = fit(c, seed, data, root, records, ticket) if phase == 'fit' else score(c, seed, data, root)
save(records / 'result.json', dict(result, phase=phase, seed=seed, status='COMPLETE', **cuda_peaks(torch)))
if __name__ == '__main__':
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('seed', type=int, choices=(0, 1, 2))
parser.add_argument('phase', choices=('fit', 'score'))
args = parser.parse_args()
run(args.seed, args.phase)