Compute-budget extrapolation

Improve a Python procedure that predicts a valid configuration and terminal measurement at a larger compute budget from smaller observed runs. This quarantined scaffold currently validates only the submission contract; low prediction error on unseen target budgets is the intended future objective after a fresh evaluator is approved.

Hard Constraints

• Use only the Python standard library; do not access the network, launch external programs, or read any file from the submitted procedure.
• Edit only /app/methods/main/extrapolate.py and keep fit(observations, target_flops) as the entry point.
• Return exactly n_embd, max_iters, and loss_prediction. The first two values must be positive non-boolean integers and the last must be finite.
• The returned configuration must use between 0.5 and 1.1 times target_flops under the compute relationship implied by the observations.
• Do not assume case identifiers, case counts, observation counts, target values, widths, iteration counts, loss ranges, or observation ordering.
• The submitted function must be deterministic for identical inputs and must not modify its input list or dictionaries.

What You Have

/app/public/observations/manifest.json is a visible contract-development package. Its root has exactly schema_version, split, and cases, with schema_version = "compute-extrapolation-visible-v1" and split = "public".

Every manifest entry has exactly case_id, file, target_flops, and num_observations. Each referenced case file has exactly case_id, target_flops, and observations. An observation has exactly:

• n_embd: a positive integer configuration width.
• max_iters: a positive integer iteration count.
• flops: a finite positive compute amount.
• final_loss: a finite terminal measurement for that run.

Within a case, compute follows one consistent positive coefficient times n_embd**2 * max_iters; infer it from the observations rather than hard-coding a visible value. The editable starter is /app/methods/main/extrapolate.py.

Run python /app/selfcheck.py in the image, or python environment/selfcheck.py from the task directory, to check the visible schema and submission contract. The self-check validates strict schemas, output keys and types, budget validity, determinism, input immutability, and allowed imports; it does not measure prediction quality or estimate private performance.

What You Submit

Submit the edited file at /app/methods/main/extrapolate.py. It must expose exactly this callable interface:

def fit(observations: list[dict], target_flops: float) -> dict:
    ...

The returned dictionary must have exactly n_embd, max_iters, and loss_prediction. The evaluator recomputes the configuration's compute from the private observation family before measuring quality.

How It Is Judged

The current verifier is intentionally inactive: it does not execute the submitted procedure or measure prediction quality, and its contract-only result is not difficulty evidence. A future release evaluator would invoke fit independently on private observation families and target budgets, validate the full contract, measure error against sealed task-matched curves, map raw error per target or precommitted family, and only then aggregate; lower raw error is better. That evaluator remains blocked pending fresh undisclosed sweeps, isolation evidence, and task-matched measurements.

Common Pitfalls

• Hard-coding visible targets, observation counts, widths, coefficients, or answers.
• Returning floats or booleans for integer configuration fields, extra keys, non-finite values, or an off-budget configuration.
• Mutating or reordering the supplied observation objects.
• Depending on files, packages, subprocesses, network access, or process-global state.
• Treating the contract-only self-check as a quality score.
• Fitting only the visible numeric examples instead of implementing a robust extrapolation procedure.