Bind GINO-Greif trilinear adapter, grouped support and CPU cost gates
This commit is contained in:
1 parent
367da00d71
commit
8810276beb
9 files changed
+2229
-15
No files matched your search
@@ -0,0 +1,88 @@
|
||||
"""Audit a fixed set of original Greif geometry and immutable input arrays on CPU."""
|
||||
|
||||
import argparse
|
||||
import ast
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
import numpy as np
|
||||
import torch
|
||||
|
||||
import track_b_gino_greif_prepare as preparation
|
||||
from track_b_gino_greif_adapter import COLUMNS, GRID, deposit, gather, stencil
|
||||
from track_b_gino_shapenet_entry import BASE, checked, read, save, sha
|
||||
|
||||
|
||||
def fixed_cases(pilot, folds):
|
||||
selected = {}
|
||||
for fold, data in folds.items():
|
||||
for role in ('learning', 'test'):
|
||||
cases = sorted(data['parts'][role], key=lambda case: (pilot['parts'][case]['nodes'], case))
|
||||
for index in (0, len(cases) // 2, len(cases)-1):
|
||||
selected.setdefault(cases[index], []).append((fold, role))
|
||||
return selected
|
||||
|
||||
|
||||
def geometry(pilot, case, roles):
|
||||
row = pilot['parts'][case]
|
||||
source = pilot['geometry'][case]
|
||||
with np.load(checked(source['path'], source['sha256']), allow_pickle=False) as archive:
|
||||
points, ids, raw_mass = (archive[name].copy() for name in ('points','raw_ids','mass'))
|
||||
|
||||
def inputs(name):
|
||||
path = BASE / row['output'] / name
|
||||
return np.load(checked(path, row['output_sha256'][name]), allow_pickle=False)
|
||||
|
||||
if len(ids) != row['nodes'] or not np.array_equal(ids, inputs('raw_ids.npy')) or not np.array_equal(raw_mass, inputs('mass.npy')):
|
||||
raise ValueError('Frozen original node/mass identity differs for ' + case)
|
||||
x = torch.from_numpy(np.asarray(inputs('features.npy'), dtype=np.float32))
|
||||
mass = torch.from_numpy(raw_mass.astype(np.float32))
|
||||
corner, weight = stencil(points, ids)
|
||||
grid, cell_mass = deposit(x, mass, corner, weight)
|
||||
reopened = gather(grid[:len(COLUMNS)], corner, weight)
|
||||
if reopened.shape != x.shape or not bool(torch.isfinite(reopened).all()):
|
||||
raise ValueError('Grid readout does not cover all original nodes')
|
||||
if (weight.sum(1) - 1.).abs().max().item() > 2e-7:
|
||||
raise ValueError('Incomplete trilinear node weights')
|
||||
ref_mass = mass.double() / mass.double().sum()
|
||||
source_integral = ref_mass @ x.double()
|
||||
scale = (ref_mass @ x.double().abs()).clamp_min(1.)
|
||||
grid_integral = grid[:len(COLUMNS)].reshape(len(COLUMNS),-1).double() @ cell_mass.double()
|
||||
relative_integral_error = ((source_integral-grid_integral).abs()/scale).max().item()
|
||||
relative_mass_error = abs(cell_mass.double().sum().item()-1.)
|
||||
if relative_mass_error > 2e-5 or relative_integral_error > 2e-5:
|
||||
raise ValueError('Mass-weighted transfer failed the numerical preflight')
|
||||
error = (reopened - x).double()
|
||||
column_rms = (ref_mass @ error.square()).sqrt().tolist()
|
||||
return dict(case=case, examined_roles=roles, original_nodes=len(ids), occupied_cells=int((cell_mass>0).sum()),
|
||||
mass_relative_error=relative_mass_error, field_integral_relative_error=relative_integral_error,
|
||||
untrained_round_trip_rms_by_column=column_rms,
|
||||
geometry_sha256=source['sha256'], feature_sha256=row['output_sha256']['features.npy'])
|
||||
|
||||
|
||||
def audit():
|
||||
if os.environ.get('CUDA_VISIBLE_DEVICES') != '':
|
||||
raise PermissionError('Geometry preparation requires CUDA hidden')
|
||||
torch.set_num_threads(1)
|
||||
root = preparation.REVIEW_ROOT
|
||||
candidate = read(root/'preparation-binding.json')
|
||||
if candidate != preparation.binding() or (root/'geometry-audit.json').exists():
|
||||
raise PermissionError('Only the new frozen preparation candidate')
|
||||
source = Path(__file__).with_name('gre24_features_v2.py')
|
||||
columns = next(ast.literal_eval(stmt.value) for stmt in ast.parse(source.read_text()).body
|
||||
if isinstance(stmt, ast.Assign) and any(isinstance(x, ast.Name) and x.id == 'COLUMNS' for x in stmt.targets))
|
||||
if columns != COLUMNS:
|
||||
raise ValueError('Original 19-column layout differs')
|
||||
pilot = read(checked(preparation.PILOT, preparation.PINS[str(preparation.PILOT)]))
|
||||
cases = fixed_cases(pilot, candidate['folds'])
|
||||
rows = [geometry(pilot, case, scope) for case, scope in cases.items()]
|
||||
save(root/'geometry-audit.json', dict(status='PASS', candidate_sha256=sha(root/'preparation-binding.json'),
|
||||
size=GRID, columns=list(COLUMNS), cases=len(rows),
|
||||
selection='minimum, median and maximum node counts within each fold learning and test role, deduplicated',
|
||||
actual_heldout_labels_read=0, actual_gpu_queries=0, rows=rows))
|
||||
print(len(rows), sum(r['original_nodes'] for r in rows))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
argparse.ArgumentParser(description=__doc__).parse_args()
|
||||
audit()
|
||||
@@ -0,0 +1,100 @@
|
||||
"""Greif node-to-grid integral, Tucker FNO, and grid-to-original-node readout."""
|
||||
|
||||
from itertools import product
|
||||
|
||||
import numpy as np
|
||||
import torch
|
||||
from torch import nn
|
||||
|
||||
|
||||
GRID = 64
|
||||
WIDTH = 32
|
||||
MODES = (24, 24, 24)
|
||||
COLUMNS = ('Vf', 'grad_Vf_x', 'grad_Vf_y', 'grad_Vf_z', 'Di_star',
|
||||
'grad_Di_x', 'grad_Di_y', 'grad_Di_z', 'Dw', 'Dw_star',
|
||||
'grad_Dw_x', 'grad_Dw_y', 'grad_Dw_z', 'Sxx', 'Sxy', 'Sxz', 'Syy', 'Syz', 'Szz')
|
||||
CHUNK = 8192
|
||||
|
||||
|
||||
def stencil(points, raw_ids, size=GRID):
|
||||
"""An isotropic part cube with one lattice cell of margin on each face."""
|
||||
xyz = np.asarray(points, dtype=np.float64)
|
||||
ids = np.asarray(raw_ids)
|
||||
if (size < 5 or xyz.ndim != 2 or xyz.shape[1] != 3 or len(xyz) < 2
|
||||
or not np.isfinite(xyz).all() or ids.shape != (len(xyz),)
|
||||
or ids.dtype.kind not in 'iu' or not np.all(ids[1:] > ids[:-1])):
|
||||
raise ValueError('Original coordinates and strictly ordered raw node IDs required')
|
||||
low, high = xyz.min(axis=0), xyz.max(axis=0)
|
||||
side = (high - low).max()
|
||||
if not np.isfinite(side) or side <= 0:
|
||||
raise ValueError('Invalid bounding cube')
|
||||
lattice = (xyz - (low + high) / 2) / side * (size - 3) + (size - 1) / 2
|
||||
if not np.isfinite(lattice).all() or lattice.min() < .999999 or lattice.max() > size - 1.999999:
|
||||
raise ValueError('Node outside fixed interpolation cube')
|
||||
base = np.floor(lattice).astype(np.int64)
|
||||
frac = lattice - base
|
||||
vertices, weights = [], []
|
||||
for bits in product((0, 1), repeat=3):
|
||||
corners = base + np.asarray(bits)
|
||||
vertices.append(np.ravel_multi_index(corners.T, (size, size, size)))
|
||||
weights.append(np.prod(np.where(bits, frac, 1 - frac), axis=1))
|
||||
return (torch.from_numpy(np.stack(vertices, axis=1)),
|
||||
torch.from_numpy(np.stack(weights, axis=1).astype(np.float32)))
|
||||
|
||||
|
||||
def deposit(features, mass, vertices, weights, size=GRID):
|
||||
if (features.ndim != 2 or features.shape[1] != len(COLUMNS) or mass.shape != features.shape[:1]
|
||||
or vertices.shape != (len(mass), 8) or weights.shape != vertices.shape
|
||||
or mass.dtype != torch.float32 or features.dtype != torch.float32 or weights.dtype != torch.float32
|
||||
or vertices.dtype != torch.int64 or not torch.isfinite(features).all()
|
||||
or not torch.isfinite(mass).all() or torch.any(mass <= 0)):
|
||||
raise ValueError('Expected full original FP32 features, positive mass and reviewed stencil')
|
||||
total = mass.sum()
|
||||
if not torch.isfinite(total) or total <= 0:
|
||||
raise ValueError('Invalid total nodal mass')
|
||||
volume = mass / total
|
||||
cells = size**3
|
||||
numerator = features.new_zeros((cells, len(COLUMNS)))
|
||||
denominator = features.new_zeros(cells)
|
||||
# Keep the (nodes × 8 × channels) product out of memory.
|
||||
for corner in range(8):
|
||||
ids = vertices[:, corner]
|
||||
weighted_mass = volume * weights[:, corner]
|
||||
denominator.index_add_(0, ids, weighted_mass)
|
||||
numerator.index_add_(0, ids, weighted_mass[:, None] * features)
|
||||
occupied = denominator > 0
|
||||
field = numerator / torch.where(occupied, denominator, 1.)[:, None]
|
||||
grid = torch.cat((field, occupied[:, None].to(field.dtype)), dim=1)
|
||||
return grid.T.reshape(len(COLUMNS) + 1, size, size, size), denominator
|
||||
|
||||
|
||||
def gather(grid, vertices, weights):
|
||||
channels = grid.shape[0]
|
||||
values = grid.reshape(channels, -1).T
|
||||
return torch.cat([
|
||||
(values[vertices[lo:lo + CHUNK]] * weights[lo:lo + CHUNK, :, None]).sum(1)
|
||||
for lo in range(0, len(vertices), CHUNK)
|
||||
])
|
||||
|
||||
|
||||
class GreifGINO(nn.Module):
|
||||
"""Fixed trilinear integral layers around the pinned GINO-family spectral core."""
|
||||
|
||||
def __init__(self, size=GRID, modes=MODES):
|
||||
super().__init__()
|
||||
from neuralop.models import FNO
|
||||
|
||||
self.size = size
|
||||
self.fno = FNO(list(modes), hidden_channels=WIDTH, in_channels=len(COLUMNS) + 1,
|
||||
out_channels=WIDTH, norm='group_norm', use_mlp=True,
|
||||
mlp={'expansion': 1., 'dropout': 0.}, domain_padding=.125,
|
||||
factorization='tucker', rank=.4)
|
||||
self.readout = nn.Sequential(nn.Linear(WIDTH + len(COLUMNS), 64), nn.GELU(), nn.Linear(64, 1))
|
||||
nn.init.zeros_(self.readout[-1].weight)
|
||||
nn.init.zeros_(self.readout[-1].bias)
|
||||
|
||||
def forward(self, features, mass, vertices, weights):
|
||||
grid, _ = deposit(features, mass, vertices, weights, self.size)
|
||||
latent = self.fno(grid[None])[0]
|
||||
at_nodes = gather(latent, vertices, weights)
|
||||
return self.readout(torch.cat((at_nodes, features), dim=1))[:, 0]
|
||||
@@ -10,9 +10,13 @@ from track_b_gino_shapenet_entry import BASE, checked, read, save, sha
|
||||
|
||||
|
||||
ROOT = BASE / 'artifacts/track-b-gino-greif-preparation-2026-11-19'
|
||||
STATUS = 'PREPARED_PENDING_ADAPTER_REVIEW_TIMING_AND_PHASE_PROJECTION'
|
||||
REVIEW_ROOT = ROOT / 'adapter-review'
|
||||
STATUS = 'CPU_ADAPTER_READY_PENDING_EXECUTION_BINDING_AND_MEASURED_COST'
|
||||
PILOT = BASE / 'artifacts/phase2-h2-pilot-2026-11-17/contract.json'
|
||||
QUERY = Path('/home/frank14f/MeltMind-runs/phase2-h2-s2-postfit-2026-11-17/contract.json')
|
||||
H2_REFERENCE = (QUERY.parent, QUERY.parent.with_name('phase3-seed1-postfit-2026-11-18'))
|
||||
H2_PRESSURE_AUTH = BASE / 'artifacts/track-b-h2-pressure-combined-2026-11-19/stage-authorization.json'
|
||||
H2_PRESSURE_AUTH_SHA = '42ef5913159cb0b2320f1ff1fb4fe5c2460d98fa51b240974ed662c4b7c84d0a'
|
||||
PHASE_TERMINAL = BASE / 'artifacts/phase3-item1b-fold0-labelled-recovery-2026-11-19/complete.json'
|
||||
PINS = {
|
||||
str(PILOT): '9f616974fb01f8f5cab6233273d541b3e53f5975f3632db45ab4676f911fba7b',
|
||||
@@ -21,6 +25,7 @@ PINS = {
|
||||
}
|
||||
ROLES = ('learning', 'validation', 'test')
|
||||
CAP = 200 * 3600
|
||||
EPOCHS = 200
|
||||
|
||||
|
||||
def grouped_folds(pilot, query):
|
||||
@@ -47,6 +52,8 @@ def grouped_folds(pilot, query):
|
||||
raise ValueError(f'Incomplete frozen support for fold {fold}')
|
||||
fold_records[str(fold)] = dict(counts=sizes, clock_coefficient=data['c'],
|
||||
clock_sha256=data['clock_sha256'],
|
||||
learning_nodes=data['learning_nodes'],
|
||||
family_counts={role: sum(r == role for r in owners.values()) for role in ROLES},
|
||||
parts={role: data[role] for role in ROLES})
|
||||
return fold_records
|
||||
|
||||
@@ -67,34 +74,128 @@ def project(phase_charged, approvals, epoch_seconds_by_fold, epochs, overhead_gp
|
||||
phase_cap_gpu_seconds=CAP, within_phase_cap=phase_total <= CAP)
|
||||
|
||||
|
||||
def paired_support(pilot, query, folds):
|
||||
"""Check the already frozen H2 reference roster without opening prediction or target arrays."""
|
||||
family = {r['case']: r['component_id'] for r in query['rows'] if r['included']}
|
||||
support, manifests, pins = {}, [], {}
|
||||
for root in H2_REFERENCE:
|
||||
manifest_path = root / 'predictions-manifest.json'
|
||||
terminal_path = root / 'complete.json'
|
||||
if read(terminal_path)['status'] != 'COMPLETE':
|
||||
raise ValueError('Both H2 reference postfits must be complete')
|
||||
rows = read(manifest_path)['entries']
|
||||
row_map = {(str(r['fold']), r['case']): r for r in rows}
|
||||
if len(row_map) != len(rows):
|
||||
raise ValueError('Duplicate H2 reference predictions')
|
||||
manifests.append(row_map)
|
||||
pins.update({str(p): sha(p) for p in (manifest_path, terminal_path)})
|
||||
for fold, data in folds.items():
|
||||
for case in data['parts']['test']:
|
||||
r0, r1 = (r[fold, case] for r in manifests)
|
||||
expected = (family[case], pilot['parts'][case]['nodes'])
|
||||
if (any((r['component_id'], r['nodes']) != expected for r in (r0, r1))
|
||||
or r0['query_nodes'] != r1['query_nodes'] or r1['seed0_sha256'] != r0['sha256']
|
||||
or r1['raw_ids_sha256'] != pilot['parts'][case]['output_sha256']['raw_ids.npy']):
|
||||
raise ValueError('H2 paired fold/seed full node or query support differs')
|
||||
support[fold] = dict(cases=len(data['parts']['test']), families=data['family_counts']['test'],
|
||||
references=[0, 1], raw_prediction_or_target_arrays_opened=0)
|
||||
return dict(status='REFERENCE_MANIFESTS_ALIGNED', folds=support, sha256=pins)
|
||||
|
||||
|
||||
def phase_ledger(prior, timing, gino_cap):
|
||||
auth = read(checked(H2_PRESSURE_AUTH, H2_PRESSURE_AUTH_SHA))
|
||||
h2 = auth['phase3_booked']
|
||||
if (h2['anchor_gpu_seconds'] != prior or h2['gino_formal_cap_gpu_seconds'] != gino_cap
|
||||
or h2['gino_historical_measurement_gpu_seconds_once'] != timing['prior_measurement_gpu_seconds']
|
||||
or h2['h2_pressure_formal_cap_gpu_seconds'] != 40000):
|
||||
raise ValueError('Previously adopted phase-3 bookings differ')
|
||||
historic = timing['prior_measurement_gpu_seconds']
|
||||
total = prior + historic + gino_cap + h2['h2_pressure_formal_cap_gpu_seconds']
|
||||
if total != h2['total_gpu_seconds'] or total >= CAP:
|
||||
raise ValueError('Phase-3 published accounting differs')
|
||||
return dict(settled_phase3_through_1b_gpu_seconds=prior,
|
||||
gino_measurement_once_gpu_seconds=historic, gino_shapenet_formal_reserve_gpu_seconds=gino_cap,
|
||||
h2_pressure_unsettled_max_gpu_seconds=40000, accounted_gpu_seconds=total,
|
||||
phase_cap_gpu_seconds=CAP, upper_remaining_before_other_bookings_gpu_seconds=CAP-total,
|
||||
h2_stage_authorization_sha256=H2_PRESSURE_AUTH_SHA,
|
||||
other_unsettled_bookings_gpu_seconds=None, measured_greif_epoch_seconds=None,
|
||||
complete_projection=None, status='HOLD_PENDING_DISPATCH_LEDGER_AND_TWO_MEASURED_EPOCHS')
|
||||
|
||||
|
||||
def first_epoch_gate(candidate, receipts, *, other_unsettled, approved_greif_cap, remaining_overhead):
|
||||
"""Charge the two initial full epochs via their bookings once, then project only remaining work."""
|
||||
p = candidate['projection']
|
||||
amounts = (other_unsettled, approved_greif_cap, remaining_overhead)
|
||||
if any(type(v) not in (int, float) or not math.isfinite(v) or v < 0 for v in amounts) or approved_greif_cap == 0:
|
||||
raise ValueError('Explicit phase reservations, approved Greif cap and overhead needed')
|
||||
cap = min(approved_greif_cap, p['upper_remaining_before_other_bookings_gpu_seconds'] - other_unsettled)
|
||||
if set(receipts) != set(candidate['folds']):
|
||||
return dict(status='HOLD_MISSING_BOTH_EPOCH_RECEIPTS', release_epoch2=False)
|
||||
spent = work = 0.
|
||||
for fold, expected in candidate['folds'].items():
|
||||
r = receipts[fold]
|
||||
if (r['fold'], r['seed'], r['epoch'], r['learning_cases'], r['learning_nodes'], r['heldout_target_reads']) != (
|
||||
int(fold), 0, 1, len(expected['parts']['learning']), expected['learning_nodes'], 0):
|
||||
raise ValueError('First epoch receipt is not this fold’s full learning scope')
|
||||
t, charge = r['epoch_seconds'], r['booked_gpu_seconds']
|
||||
if not all(type(v) in (float,int) and math.isfinite(v) for v in (t,charge)) or not 0 < t <= charge:
|
||||
raise ValueError('Missing measured full epoch or booked setup time')
|
||||
spent += charge
|
||||
work += (2 * candidate['epochs'] - 1) * t
|
||||
projected = spent + math.ceil(1.25 * work) + remaining_overhead
|
||||
within = projected <= cap
|
||||
return dict(status='COST_WITHIN_CAP' if within else 'STOP_PROJECTED_CAP',
|
||||
charged_first_epochs_and_setup_gpu_seconds=spent, remaining_train_gpu_seconds=work,
|
||||
remaining_overhead_gpu_seconds=remaining_overhead, safety_factor=1.25,
|
||||
projected_greif_gpu_seconds=projected, phase_projection_gpu_seconds=p['accounted_gpu_seconds'] +
|
||||
other_unsettled + projected, effective_greif_cap_gpu_seconds=cap,
|
||||
release_epoch2=within)
|
||||
|
||||
|
||||
def binding():
|
||||
from track_b_gino_greif_adapter import COLUMNS, GRID, MODES, WIDTH
|
||||
|
||||
pilot, query, terminal = (read(checked(path, PINS[str(path)])) for path in (PILOT, QUERY, PHASE_TERMINAL))
|
||||
folds = grouped_folds(pilot, query)
|
||||
reference_formal = reference.contract()
|
||||
timing = reference_formal['formal']['timing']
|
||||
prior = terminal['cumulative_phase3_gpu_seconds']
|
||||
return dict(status=STATUS, handoff='h-539a65e1', working_entry='preparation_only',
|
||||
folds=folds, seeds=[0, 1],
|
||||
return dict(status=STATUS, handoff='h-1789ca7e', working_entry='preparation_only',
|
||||
folds=folds, seeds=[0, 1], epochs=EPOCHS, h2_reference_support=paired_support(pilot, query, folds),
|
||||
jobs=[dict(fold=fold, seed=seed) for fold in (0, 1) for seed in (0, 1)],
|
||||
sources=PINS,
|
||||
reuse_h2=dict(features='original 19 standardized on each fold learning only', geometry='full retained tet nodes',
|
||||
mass='original positive nodal mass', input_clock='original FP64 Vf and frozen learning c',
|
||||
train_target='same normalized residual as H2 candidate', readout='same cF and seconds decode',
|
||||
case_query='original fixed PPS/query multiplicity and raw IDs', target_reads_in_preparation=0),
|
||||
adapter_candidate=dict(status='NEEDS_SCIENTIFIC_REVIEW',
|
||||
method='propose GNO/FNO/GNO with same node features carried into and out of the latent grid',
|
||||
open=['latent grid and feature transport', 'training epochs and learning schedule',
|
||||
'phase pool and test target access sequencing']),
|
||||
projection=dict(settled_phase3_through_1b_gpu_seconds=prior,
|
||||
gino_measurement_once_gpu_seconds=timing['prior_measurement_gpu_seconds'],
|
||||
gino_shapenet_formal_reserve_gpu_seconds=40000, h2_pressure_unsettled_max_gpu_seconds=40000,
|
||||
phase_cap_gpu_seconds=CAP, measured_greif_epoch_seconds=None,
|
||||
complete_projection=None, status='BLOCKED_PENDING_COMPLETE_PHASE_PROJECTION'),
|
||||
adapter_candidate=dict(identity='GINO-Greif fixed trilinear GNO / Tucker FNO / trilinear GNO',
|
||||
resolution=[GRID]*3, width=WIDTH, modes=list(MODES), columns=list(COLUMNS),
|
||||
first_grid_input='nineteen mass-weighted trilinear means and one occupancy bit',
|
||||
coordinates='isotropic part bounding cube, one grid cell margin',
|
||||
readout='tri-linear gather at original nodes plus same original 19 column skip',
|
||||
pressure_or_sdf_channels_added=False,
|
||||
model_environment=reference_formal['environment']),
|
||||
training_candidate=dict(schedule='same H2 AdamW, 10 warmup, 190 cosine, 200 full epochs',
|
||||
epoch_shuffle='PCG64 SeedSequence([seed, epoch])', loss='same H2 node-equal per-part weighted FP32 MSE and gradient clip 1',
|
||||
no_validation_selection=True, match='exact fold × seed, matching H2 features and residual target',
|
||||
model_choice_before_launch=True),
|
||||
scoring_custody=dict(review_gate=True, require_all_four_final_checkpoints=True,
|
||||
predictions_all_full_nodes_frozen_before_target_access=True,
|
||||
planned_single_read_of_each_original_test_case=True,
|
||||
paper_gate_applies_to_shape_pressure_only=True, use_frozen_pps_multiplicity=True,
|
||||
report=['relative L2','last_location/Rg','Kendall tau-b'],
|
||||
topology_weld_line_claims=False),
|
||||
projection=phase_ledger(prior, timing, reference_formal['formal']['total_gpu_wall_seconds']),
|
||||
admission=dict(preferred_ordinals=[0,1,2], last_ordinal=3, gpu3_single_task=True,
|
||||
require_actual_stage_approval=True, max_two_initial_seed0_full_epochs_before_projection=True),
|
||||
production_guard_limits=reference_formal['limits'],
|
||||
launch_authorized=False,
|
||||
code_sha256={str(path): sha(path) for path in (
|
||||
Path(__file__).resolve(), reference.SOURCES/'phase2_h2_data.py',
|
||||
reference.SOURCES/'phase2_residual_math.py', reference.SOURCES/'track_b_gino_formal_guard.py')})
|
||||
reference.SOURCES/'phase2_residual_math.py', reference.SOURCES/'track_b_gino_formal_guard.py',
|
||||
reference.SOURCES/'s2_recovery_gpu_supervisor.py', reference.SOURCES/'track_b_gino_greif_adapter.py',
|
||||
reference.SOURCES/'gre24_features_v2.py', reference.SOURCES/'s2_custody_statistics.py',
|
||||
reference.SOURCES/'phase2_h2_model.py')})
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
@@ -103,6 +204,6 @@ if __name__ == '__main__':
|
||||
args = parser.parse_args()
|
||||
c = binding()
|
||||
if args.write_binding:
|
||||
ROOT.mkdir(exist_ok=False)
|
||||
save(ROOT/'preparation-binding.json', c)
|
||||
REVIEW_ROOT.mkdir(exist_ok=False)
|
||||
save(REVIEW_ROOT/'preparation-binding.json', c)
|
||||
print(json.dumps({key: c[key] for key in ('status', 'jobs', 'projection', 'launch_authorized')}, indent=2))
|
||||
Reference in new issue
Block a user