Python API Reference#
The Python API reference focuses on stable extension points and public data structures. Internal helpers can have docstrings, but they should not be treated as public compatibility promises unless they appear here.
Recipes#
.. py:module:: noema_lab.core.recipes
.. py:exception:: RecipeValidationError :module: noema_lab.core.recipes
.. py:class:: RecipeDiagnostic(severity: ‘str’, code: ‘str’, message: ‘str’, path: ‘str’ = ‘$’) :module: noema_lab.core.recipes
.. py:class:: RecipeStep(id: ‘str’, op: ‘str’, params: ‘JsonDict’ =
.. py:class:: Recipe(name: ‘str’, steps: ‘List[RecipeStep]’, description: ‘Optional[str]’ = None, schema_version: ‘int’ = 1, metadata: ‘JsonDict’ =
.. py:class:: RecipeCompilation(raw: ‘JsonDict’, mode: ‘str’, recipe: ‘Optional[Recipe]’, effective_recipe: ‘Optional[Recipe]’, diagnostics: ‘List[RecipeDiagnostic]’ =
.. py:function:: compile_recipe(data, *, mode=’compat’, registry=None) :module: noema_lab.core.recipes
Compile a raw v1 recipe into normalized and effective representations.
data may be a raw mapping or an already parsed :class:Recipe.
compat preserves v1 conveniences while reporting unknown fields and
implicit step IDs as warnings. strict reports those conditions as
errors. Unknown fields are retained in both modes so diagnostics never
cause a lossy round-trip.
When an operation registry is supplied, defaults declared in each operation’s parameter schema are recursively materialized into the effective recipe. The normalized recipe always retains the author’s original parameter choices.
.. py:function:: recipe_from_dict(data) :module: noema_lab.core.recipes
Parse a v1 recipe using compatibility-mode compiler semantics.
.. py:function:: require_strict_recipe(recipe) :module: noema_lab.core.recipes
Reject compatibility conveniences before an executable inspection.
.. py:function:: validate_recipe_step_id(step_id) :module: noema_lab.core.recipes
Return a step ID that is safe as one artifact-directory component.
Recipe Templates#
.. py:module:: noema_lab.core.recipe_templates
.. py:exception:: RecipeTemplateCatalogError :module: noema_lab.core.recipe_templates
.. py:exception:: RecipeTemplateInstantiationError :module: noema_lab.core.recipe_templates
.. py:class:: RecipeTemplateEditorBinding(step_id: ‘str’, op: ‘str’, param: ‘str’) :module: noema_lab.core.recipe_templates
.. py:class:: RecipeTemplateDefinition(id: ‘str’, label: ‘str’, task_id: ‘str’, editor: ‘str’, recipe_path: ‘str’, order: ‘int’, default: ‘bool’, status: ‘str’, execution_profile: ‘Optional[ExecutionProfileRef]’ = None, starter_resource: ‘Optional[str]’ = None, editor_bindings: ‘Dict[str, RecipeTemplateEditorBinding]’ =
.. py:class:: RecipeTemplateCatalog(templates: ‘Dict[str, RecipeTemplateDefinition]’, schema_version: ‘int’ = 1) :module: noema_lab.core.recipe_templates
.. py:class:: RecipeTemplateProvenance(template_id: ‘str’, catalog_schema_version: ‘int’, template_digest: ‘str’, source_kind: ‘str’, source_reference: ‘str’, source_digest: ‘str’, overrides_digest: ‘str’, schema_version: ‘int’ = 1, kind: ‘str’ = ‘noema.recipe_template_provenance’) :module: noema_lab.core.recipe_templates
.. py:class:: RecipeTemplateInstantiation(recipe: ‘Recipe’, provenance: ‘RecipeTemplateProvenance’) :module: noema_lab.core.recipe_templates
.. py:class:: RecipeTemplateInspection(template: ‘RecipeTemplateDefinition’, available: ‘bool’, validation_status: ‘str’, errors: ‘List[str]’ =
.. py:class:: RecipeTemplateCatalogInspection(rows: ‘List[RecipeTemplateInspection]’, schema_version: ‘int’ = 1) :module: noema_lab.core.recipe_templates
.. py:function:: instantiate_recipe_template(template_id, project_root, registry, *, catalog=None, overrides=None) :module: noema_lab.core.recipe_templates
Instantiate a catalog starter as an ordinary, validated recipe.
A project file at the catalog entry’s recipe_path is an explicit
override. When it is absent, the catalog’s packaged starter_resource
is used. The chosen source is read once, then overrides and canonical
provenance are applied before strict compilation and registry planning.
Invalid project overrides are never hidden by falling back to the built-in
starter.
Recipe Matrices#
.. py:module:: noema_lab.core.matrix
.. py:exception:: RecipeMatrixError :module: noema_lab.core.matrix
Raised when a recipe matrix cannot be normalized or expanded.
.. py:class:: MatrixDiagnostic(severity: ‘str’, code: ‘str’, message: ‘str’, path: ‘str’) :module: noema_lab.core.matrix
.. py:class:: CanonicalRecipeMatrix(definition: ‘JsonDict’, source: ‘str’, diagnostics: ‘Tuple[MatrixDiagnostic, …]’ =
.. py:function:: matrix_variant_id(selection) :module: noema_lab.core.matrix
Return the stable, filesystem-safe identity of one typed selection.
The ID deliberately excludes the recipe display name and matrix index. It
therefore survives harmless recipe renames and dimension reordering. JSON
values are represented with explicit type tags before hashing so Python’s
equality aliases (notably True == 1) cannot collapse distinct points.
.. py:function:: canonicalize_recipe_matrix(recipe, *, strict_legacy=False, max_variants=256) :module: noema_lab.core.matrix
Return one validated canonical matrix without mutating recipe.
metadata.matrix is authoritative. The v1 metadata.sweeps and
metadata.ui_sweeps maps are accepted in compatibility mode and are
translated into typed dimensions bound to concrete step parameters.
Callers that persist public recipes can set strict_legacy=True to
reject those compatibility fields.
.. py:function:: expand_recipe_matrix(recipe, *, strict_legacy=False, max_variants=256) :module: noema_lab.core.matrix
Expand a recipe matrix into deterministic concrete recipe payloads.
.. py:function:: materialize_recipe_matrix_selection(recipe, selection, *, strict_legacy=False, max_variants=256) :module: noema_lab.core.matrix
Materialize one complete, typed matrix selection without changing recipe.
Additional coordinates are retained as provenance, but every dimension declared by the recipe must be selected from its authored value list.
.. py:function:: matrix_values_for_step_param(recipe, step_id, param_name, *, strict_legacy=False) :module: noema_lab.core.matrix
Return dimension values directly bound to one step parameter, if any.
Recipe Variants#
.. py:module:: noema_lab.core.variants
.. py:exception:: RecipeVariantPlanningError :module: noema_lab.core.variants
Raised when an authored recipe or one of its variants cannot run.
.. py:class:: PlannedRecipeVariant(matrix_variant_id, matrix_index, matrix_selection, recipe) :module: noema_lab.core.variants
One ordered, strictly validated concrete point in a recipe matrix.
.. py:class:: RecipeVariantPlan(recipe, canonical_matrix, variants) :module: noema_lab.core.variants
Canonical matrix metadata and its validated concrete variants.
.. py:method:: RecipeVariantPlan.to_expansion_dict() :module: noema_lab.core.variants
Return the v1 expansion envelope while retaining canonical metadata.
.. py:function:: plan_recipe_variants(recipe_payload, registry, *, strict_legacy=False, max_variants=256) :module: noema_lab.core.variants
Strictly compile and registry-validate a matrix and every concrete point.
Matrix-disabled recipes intentionally return no variants, preserving the
v1 expansion contract. Use :func:prepare_single_run_recipe for the
ordinary one-recipe execution path.
.. py:function:: prepare_single_run_recipe(recipe_payload, registry, *, strict_legacy=False, max_variants=256) :module: noema_lab.core.variants
Return one validated concrete recipe or reject an unresolved matrix.
Concrete v1 recipes that already carry matrix_selection but predate
matrix_variant_id remain accepted; the returned normalized copy is
upgraded with the stable ID. A supplied new ID must match the selection.
.. py:function:: prepare_compiled_single_run_recipe(recipe, *, strict_legacy=False, max_variants=256) :module: noema_lab.core.variants
Gate an already compiled recipe without repeating registry resolution.
This is the executor-facing half of :func:prepare_single_run_recipe.
Callers must have compiled strictly and must still create an execution plan;
the split keeps preflight to one compiler pass and one planner pass.
Operations#
.. py:module:: noema_lab.core.operations
.. py:exception:: OperationError :module: noema_lab.core.operations
.. py:exception:: ExecutionCancelled :module: noema_lab.core.operations
Raised at cooperative cancellation checkpoints.
.. py:function:: normalize_input_metadata_requirements(value, operation_id=’operation’, *, input_names=None) :module: noema_lab.core.operations
Normalize typed metadata requirements for operation inputs.
all_of paths must all be guaranteed by the producer. any_of paths
express runtime-compatible alternatives, such as one of
original_shapes, original_shape, or shape.
.. py:class:: OperationResult(outputs: ‘Dict[str, Artifact]’ =
.. py:class:: OperationContext(recipe_name: ‘str’, step_id: ‘str’, params: ‘JsonDict’, inputs: ‘Mapping[str, Artifact]’, run_dir: ‘Path’, step_dir: ‘Path’, progress_sink: ‘Optional[Callable[[JsonDict], None]]’ = None, master_seed: ‘Optional[int]’ = None, seed_namespace: ‘Optional[str]’ = None, cancellation_token: ‘Optional[Any]’ = None) :module: noema_lab.core.operations
.. py:method:: OperationContext.is_cancelled() :module: noema_lab.core.operations
Return whether cooperative cancellation has been requested.
Operation implementations should poll this at natural batch or loop
boundaries. The token is deliberately duck-typed so the executor can
adapt existing ``threading.Event`` callers without coupling operation
contracts to a particular scheduler implementation.
.. py:method:: OperationContext.raise_if_cancelled(message=None) :module: noema_lab.core.operations
Raise the executor's cancellation exception when requested.
.. py:class:: Operation() :module: noema_lab.core.operations
.. py:method:: Operation.runtime_availability(params) :module: noema_lab.core.operations
Return parameter-aware availability for an ordinary execution.
Most operations have one implementation and can rely on the static
availability exposed by :meth:`describe`. Operations whose runtime
dependency changes with a parameter (for example a local renderer
versus a masked-language-model renderer) override this hook.
.. py:method:: Operation.validate_preflight(params, inputs=None) :module: noema_lab.core.operations
Validate parameter/input combinations before evidence is created.
JSON-schema validation handles individual fields. Operations override
this hook for cross-field or conditionally-required combinations that
otherwise could fail only after dispatch.
.. py:method:: Operation.execution_instance() :module: noema_lab.core.operations
Return a per-step dispatch view of this registered operation.
A shallow copy isolates ordinary scalar instance state while retaining
deliberate references such as loaded models and callbacks. Operations
that need deeper isolation can override this hook. Undeclared
operations are nevertheless scheduled exclusively.
Materialization#
.. py:module:: noema_lab.core.materialization
.. py:class:: MaterializationSpec(operation_id: ‘str’, runner: ‘str’, backend: ‘str’, implementation: ‘str’ = ‘default’, status: ‘str’ = ‘implemented’, notes: ‘str’ = ‘’, parameter_bindings: ‘Mapping[str, Any]’ =
.. py:class:: ResolvedMaterialization(operation: ‘Operation’, spec: ‘MaterializationSpec’) :module: noema_lab.core.materialization
.. py:class:: MaterializationRegistry() :module: noema_lab.core.materialization
Resolve stable operation IDs into runner/backend materializations.
Recipes continue to refer to operation IDs such as wireless.channel. A runner asks this
registry for the compatible materialization it should use for its execution purpose and backend.
Execution Planning#
.. py:module:: noema_lab.core.planner
.. py:exception:: RecipePlanningError :module: noema_lab.core.planner
.. py:class:: PlannedStep(step_id, operation_id, runner, backend, implementation, materialization_id, implementation_identity, implementation_metadata, operation_contract_sha256, binding_sha256, operation, schema_version=1) :module: noema_lab.core.planner
Immutable binding between one recipe step and one implementation.
operation is the already-resolved executable object. It is intentionally
excluded from serialized evidence; its stable class identity and the full
operation contract are captured by the other fields and the parent plan.
.. py:method:: PlannedStep.params_for_execution(params) :module: noema_lab.core.planner
Apply planner-owned backend choices to a fresh parameter mapping.
.. py:method:: PlannedStep.assert_implementation_unchanged() :module: noema_lab.core.planner
Reject source or contract mutation between planning and dispatch.
.. py:class:: ExecutionPlan(runner, recipe_name, recipe_sha256, steps, operation_contracts, operation_contracts_sha256, sha256, schema_version=1, kind=’noema.execution_plan’) :module: noema_lab.core.planner
Immutable, serializable execution decision made before run side effects.
.. py:function:: plan_recipe(recipe, registry, *, runner=’benchmark_run’, backend=None, implementation=None, enforce_execution_profile=True) :module: noema_lab.core.planner
Validate and bind every recipe step to a runner materialization.
Resolution is deterministic. An explicit planner backend has highest
precedence, followed by a backend-selecting step parameter (notably
wireless_backend). auto and unspecified backends select the first
compatible implemented materialization in the operation’s declared
contract order. Selectors with a declared automatic_value are pinned
to that concrete runtime value before the plan is hashed.
.. py:function:: validate_recipe_against_registry(recipe, registry, *, enforce_execution_profile=True) :module: noema_lab.core.planner
Preserve the validation-only API without imposing a runner choice.
.. py:function:: validate_execution_plan_runtime_availability(recipe, plan) :module: noema_lab.core.planner
Recheck volatile runtime dependencies for an immutable cached plan.
.. py:function:: validate_recipe_execution_profile(recipe) :module: noema_lab.core.planner
Reject a non-conformant declared standard execution profile.
.. py:module:: noema_lab.core.executor
.. py:function:: compile_effective_recipe_for_runner(authored_recipe, registry, *, runner) :module: noema_lab.core.executor
Compile an executable recipe while preserving runner-owned RNG seeds.
Operation schemas expose numeric seed defaults for UI discoverability and
standalone calls. During Dataset Capture, however, an omitted operation
seed means “inherit the capture run’s master seed.” Default expansion must
not turn that omission into an explicit, fixed seed: 0 override.
.. py:class:: CancellationToken(event=None) :module: noema_lab.core.executor
Thread-safe cooperative cancellation shared by a run and its operations.
An existing :class:threading.Event can be wrapped for compatibility with
older callers. Cancellation is cooperative: the executor checks the token
at scheduling boundaries, while long-running operations can call
ctx.raise_if_cancelled() at safe interruption points.
.. py:method:: CancellationToken.cancel(reason=None) :module: noema_lab.core.executor
Request cancellation and return whether this was the first request.
.. py:method:: CancellationToken.is_set() :module: noema_lab.core.executor
Expose the Event spelling for compatibility with existing code.
.. py:module:: noema_lab.core.plan_cache
Bounded, deterministic caching for immutable execution plans.
The public cache key is semantic and reproducible. The private lookup slot is
also partitioned by the concrete :class:OperationRegistry instance because
an :class:ExecutionPlan holds executable Operation objects in addition
to its serialized contract. This prevents an otherwise identical registry
from receiving operation objects owned by an older registry.
Cache-key schema versions must be incremented whenever planner resolution semantics change without a corresponding execution-plan schema change.
.. py:class:: ExecutionPlanCacheKey(sha256, effective_recipe_sha256, operation_registry_sha256, planner_validation_sha256, runner, backend, implementation, enforce_execution_profile, schema_version=2) :module: noema_lab.core.plan_cache
Deterministic identity of every semantic input to plan resolution.
.. py:class:: ExecutionPlanCacheEvidence(outcome, key_sha256, key_schema_version, plan_sha256, effective_recipe_sha256, authored_recipe_sha256, operation_registry_sha256, planner_validation_sha256, entry_count, max_entries, schema_version=1) :module: noema_lab.core.plan_cache
Small serializable record suitable for run manifests and events.
.. py:class:: ExecutionPlanCacheResult(plan: ‘ExecutionPlan’, evidence: ‘ExecutionPlanCacheEvidence’) :module: noema_lab.core.plan_cache
.. py:class:: ExecutionPlanCacheStats(hits: ‘int’, misses: ‘int’, bypasses: ‘int’, evictions: ‘int’, entry_count: ‘int’, inflight_count: ‘int’, max_entries: ‘int’) :module: noema_lab.core.plan_cache
.. py:class:: ExecutionPlanCache(max_entries=128) :module: noema_lab.core.plan_cache
Thread-safe, bounded LRU cache for successful execution plans.
Concurrent callers for the same registry and semantic key share one
planning operation. Planning failures are never retained. clear and
invalidate advance a generation counter so a plan already in flight
cannot repopulate an explicitly invalidated cache.
.. py:method:: ExecutionPlanCache.plan(recipe, registry, *, runner=’benchmark_run’, backend=None, implementation=None, enforce_execution_profile=True, authored_recipe=None, use_cache=True) :module: noema_lab.core.plan_cache
Resolve ``recipe`` and return cache evidence with the plan.
``recipe`` is the effective recipe submitted to the planner.
``authored_recipe`` is optional because it does not change planner
output. Callers that preserve authored/effective provenance should
supply it so the run-specific authored digest is included in evidence
without reducing hits for identical effective recipes. Set
``use_cache=False`` for an explicit one-shot bypass.
.. py:method:: ExecutionPlanCache.invalidate(*, key_sha256=None, registry=None) :module: noema_lab.core.plan_cache
Remove matching entries and prevent in-flight repopulation.
With no filters this is equivalent to :meth:`clear`. A semantic key
invalidates all registry partitions for that key unless ``registry``
is supplied as an additional filter. Returns the number removed.
.. py:function:: build_execution_plan_cache_key(recipe, registry, *, runner=’benchmark_run’, backend=None, implementation=None, enforce_execution_profile=True) :module: noema_lab.core.plan_cache
Build the stable semantic key used by :class:ExecutionPlanCache.
Artifacts#
.. py:module:: noema_lab.core.artifacts
.. py:class:: Artifact(kind: ‘str’, path: ‘Path’, metadata: ‘JsonDict’ =
Benchmarks#
.. py:module:: noema_lab.core.benchmarks
.. py:exception:: BenchmarkError :module: noema_lab.core.benchmarks
.. py:class:: BenchmarkRecipe(id: ‘str’, path: ‘Path’, label: ‘Optional[str]’ = None, role: ‘str’ = ‘candidate’, params: ‘JsonDict’ =
.. py:class:: BenchmarkPack(id: ‘str’, version: ‘str’, recipes: ‘List[BenchmarkRecipe]’, path: ‘Optional[Path]’ = None, name: ‘Optional[str]’ = None, description: ‘Optional[str]’ = None, dataset: ‘JsonDict’ =
.. py:function:: benchmark_protocol_payload(pack) :module: noema_lab.core.benchmarks
Return protocol content without loader-local filesystem provenance.
.. py:function:: benchmark_protocol_sha256(pack) :module: noema_lab.core.benchmarks
Identify a benchmark protocol portably, retaining audited old IDs.
.. py:function:: benchmark_protocol_sha256_matches(pack, expected_sha256) :module: noema_lab.core.benchmarks
Accept portable identities and exact legacy snapshots during migration.
.. py:function:: finalize_resource_exhausted_benchmark(store, result_id, error, resource_guard, failure_kind=’resource_exhausted’) :module: noema_lab.core.benchmarks
Turn an abruptly killed benchmark bundle into durable failed evidence.
.. py:function:: write_benchmark_resource_guard_evidence(store, result_id, resource_guard) :module: noema_lab.core.benchmarks
Write post-run supervisor evidence without rewriting sealed result.json.
.. py:function:: reproduce_benchmark_report_artifacts(output_dir, result) :module: noema_lab.core.benchmarks
Rebuild the three human-facing reports from result.json semantics.
.. py:function:: semantic_benchmark_recipe_sha256(recipe, bindings) :module: noema_lab.core.benchmarks
Hash benchmark semantics without result-local artifact path identity.
.. py:function:: validate_trained_artifact_lineage_manifest(pack, manifest_path, *, require_lineage=None) :module: noema_lab.core.benchmarks
Validate declared fitting IDs and bytes against a frozen held-out set.
External Adapters#
.. py:module:: noema_lab.core.external_adapters
.. py:class:: ExternalAdapterOperationSpec(id: ‘str’, name: ‘str’, wraps: ‘str’, adapter_params: ‘JsonDict’ =
.. py:class:: ExternalAdapterManifest(path: ‘Path’, schema_version: ‘int’, name: ‘str’, version: ‘str’ = ‘’, description: ‘str’ = ‘’, training: ‘JsonDict’ =
.. py:class:: ManifestWrappedOperation(manifest, spec, wrapped) :module: noema_lab.core.external_adapters
Differentiable Export#
.. py:module:: noema_lab.core.training
.. py:module:: noema_lab.training.exporter
.. py:exception:: DifferentiableExportError :module: noema_lab.training.exporter
.. py:class:: ExportOptions(optimizable_steps: ‘List[str]’, loss: ‘str’, framework: ‘str’, exporter: ‘str’, source_path: ‘Optional[Path]’ = None, project_root: ‘Optional[Path]’ = None, include_starter: ‘bool’ = False) :module: noema_lab.training.exporter
.. py:class:: NeuralReceiverExportPlan(recipe: ‘Recipe’, recipe_sha256: ‘str’, receiver_step: ‘RecipeStep’, feature_step: ‘RecipeStep’, target_step: ‘RecipeStep’, feature_input: ‘str’, feature_reference: ‘str’, target_reference: ‘str’, framework: ‘str’, loss: ‘str’, feature_kind: ‘str’, target_kind: ‘str’, capture_plan: ‘TrainingCapturePlan’, project_root: ‘Optional[Path]’ = None) :module: noema_lab.training.exporter
.. py:class:: PhaseTrackingReceiverExportPlan(recipe: ‘Recipe’, recipe_sha256: ‘str’, receiver_step: ‘RecipeStep’, feature_step: ‘RecipeStep’, pilot_context_step: ‘RecipeStep’, target_step: ‘RecipeStep’, feature_reference: ‘str’, pilot_context_reference: ‘str’, target_reference: ‘str’, framework: ‘str’, loss: ‘str’, feature_kind: ‘str’, pilot_context_kind: ‘str’, target_kind: ‘str’, capture_plan: ‘TrainingCapturePlan’, project_root: ‘Optional[Path]’ = None) :module: noema_lab.training.exporter
.. py:class:: DifferentiableExporter() :module: noema_lab.training.exporter
.. py:class:: DatasetCaptureOnlyExporter() :module: noema_lab.training.exporter
.. py:class:: PortableAiPhyAdapterExporter(exporter_id) :module: noema_lab.training.exporter
Checked-in PyTorch/ONNX starter for the sensing and beam-policy adapters.
.. py:class:: TextSemanticJSCCExporter() :module: noema_lab.training.exporter
.. py:class:: TaskHeadExporter() :module: noema_lab.training.exporter
.. py:class:: DeepJsccExportPlan(recipe: ‘Recipe’, recipe_sha256: ‘str’, optimizable_steps: ‘List[str]’, sender_step: ‘RecipeStep’, receiver_step: ‘RecipeStep’, data_step: ‘RecipeStep’, channel_step: ‘RecipeStep’, framework: ‘str’, loss: ‘str’, snr_db: ‘List[float]’, channel: ‘str’, power_normalization_step: ‘Optional[RecipeStep]’ = None, power_normalization_target: ‘float’ = 1.0, source_path: ‘Optional[Path]’ = None, project_root: ‘Optional[Path]’ = None, template_id: ‘str’ = ‘deepjscc_image_reconstruction.reference_cnn_awgn’) :module: noema_lab.training.exporter
.. py:class:: DeepJSCCImageExporter() :module: noema_lab.training.exporter
.. py:class:: NeuralReceiverExporter() :module: noema_lab.training.exporter
.. py:class:: PhaseTrackingReceiverExporter() :module: noema_lab.training.exporter
Demo scaffold for packet-context carrier tracking.
This exporter is deliberately stricter than the generic neural-receiver exporter. It only attaches the checked-in phase-tracking example to the operation whose portable ABI carries both received symbols and public pilot context. Oracle phase truth is never part of that ABI or its required capture boundary.
.. py:class:: ModulationRecognitionExporter() :module: noema_lab.training.exporter
.. py:class:: CsiFeedbackExporter() :module: noema_lab.training.exporter
.. py:class:: MimoOfdmChannelEstimationExporter() :module: noema_lab.training.exporter
.. py:class:: DelayedCsiResourceAllocationExporter() :module: noema_lab.training.exporter
.. py:class:: ResourceAllocationExporter() :module: noema_lab.training.exporter
.. py:function:: inspect_training_capture(recipe, registry, *, optimizable_steps=None, route_loss_steps=None, project_root=None) :module: noema_lab.training.exporter
Describe editable capture signals and splits for the selected slot boundary.
.. py:function:: build_phase_tracking_receiver_export_plan(recipe, registry, *, options) :module: noema_lab.training.exporter
Resolve the graph-owned capture boundary for the phase-tracking demo.
The deployable model receives only the impaired symbols and public pilot context. Transmitted data bits are an offline supervised target. The channel’s phase trace may be selected separately for diagnostics, but is intentionally absent from both this required plan and the artifact ABI.
Capture#
.. py:module:: noema_lab.core.capture
.. py:exception:: DatasetCaptureError :module: noema_lab.core.capture
.. py:function:: validate_dataset_capture_contract(recipe, registry) :module: noema_lab.core.capture
Validate and normalize capture settings without executing the recipe.
Verification#
.. py:module:: noema_lab.core.verification
.. py:class:: CheckResult(id: ‘str’, status: ‘str’, message: ‘str’, details: ‘JsonDict’ =
.. py:function:: verify_run_bundle(store, run_id, registry=None) :module: noema_lab.core.verification
Verify one local run bundle without rerunning the experiment.
.. py:function:: verify_benchmark_result(store, result_id, registry=None, *, deep_backing_runs=False) :module: noema_lab.core.verification
Verify one local benchmark result bundle without rerunning recipes.