run_inputs

What a run is built for and captured under: the typed fixture that pins a model’s input bytes and declares its outputs, the tensors’ element types and quantization, how the run is timed, the prepared runtime a build links, the board guard a capture answers to, the model analysis that lists a model’s inputs and outputs, and the targets and IO types this heliaPROFILER builds.

Every name on this page is imported from helia_profiler.

API tier: experimental

Generated from the src/helia_profiler tree f38e378c801d34438affb680257217e0b58d2cd1.

Machine-readable model

FixtureDTypeclassIO tensor element types a fixture can declare.
FixtureFileclassA file pinned by its SHA-256; :meth:read refuses bytes that no longer match.
FixtureTimingScopeclassWhat the timed span covers.
analyze_run_modelfunctionRead a LiteRT model's public inputs and outputs without selecting an engine.
FixtureStatePolicyclassInternal state behavior; input restoration is independent of this policy.
FixtureRoleclassRole of one fixture tensor; outputs are always SIGNAL.
PerTensorQuantizationclassAPI tier: experimental
FixtureMethodclassSelect input-restoration timing and, optionally, the internal-state policy.
PerAxisQuantizationclassAPI tier: experimental
analyze_run_model_for_enginefunctionRead a model's public inputs and outputs as engine's fixture integration admits them.
FixtureTensorclassOne named model input or output with its dtype, shape and quantization.
FixtureIOclassOne model input with its fixed bytes, or one output with its expected bytes.
FixtureOutputclassOne complete output declaration, without a reference answer.
TypedFixtureModelAnalysisclassA model's public inputs and outputs in model order, with its graph facts.
TypedFixtureclassFixed input bytes and complete ordered outputs for a model.

FixtureDType()

IO tensor element types a fixture can declare.

API tier: experimental

INT8 = 'int8'

INT16 = 'int16'

INT32 = 'int32'

FLOAT16 = 'float16'

FLOAT32 = 'float32'

FixtureFile(path: Path, sha256: str) -> None

dataclass

A file pinned by its SHA-256; :meth:read refuses bytes that no longer match.

API tier: experimental

path: Path

sha256: str

read() -> bytes

FixtureTimingScope()

What the timed span covers.

INVOKE_ONLY brackets each invocation; RESTORE_AND_INVOKE brackets the timed loop, so restoring the fixed inputs before each invocation is inside the span.

API tier: experimental

INVOKE_ONLY = 'invoke_only'

RESTORE_AND_INVOKE = 'restore_and_invoke'

analyze_run_model(path: str | Path) -> TypedFixtureModelAnalysis

Read a LiteRT model’s public inputs and outputs without selecting an engine.

API tier: experimental

Parameters

Parameters of analyze_run_model
Name	Type	Default	Description
`path`	`str \| Path`	Required	The ``.tflite`` model.

Returns

Returns of analyze_run_model
Type	Description
`TypedFixtureModelAnalysis`	The input and output tensors in model order, with their dtype, shape
`TypedFixtureModelAnalysis`	and quantization, and the model's graph facts.

Raises

Errors raised by analyze_run_model
Type	Description
`ConfigError`	The model is unreadable, or a run cannot pin inputs for it, for example because an input or output shape is dynamic.

FixtureStatePolicy()

Internal state behavior; input restoration is independent of this policy.

API tier: experimental

CARRY = 'carry'

FixtureRole()

Role of one fixture tensor; outputs are always SIGNAL.

API tier: experimental

SIGNAL = 'signal'

AUX = 'aux'

PerTensorQuantization(scale: float, zero_point: int) -> None

dataclass

API tier: experimental

scale: float

zero_point: int

FixtureMethod(
    timing_scope: FixtureTimingScope,
    state_policy: FixtureStatePolicy | None = None,
    power_sync: FixturePowerSync | None = None,
) -> None

dataclass

Select input-restoration timing and, optionally, the internal-state policy.

Carry initializes the engine once, then retains internal state through warmups and measurements. It is how fixtures always run, so a build of a model with internal state records it when no policy is given. Fixed external inputs are still restored each invocation; no internal reset or source-initializer equivalence is implied.

API tier: experimental

timing_scope: FixtureTimingScope

state_policy: FixtureStatePolicy | None = None

power_sync: FixturePowerSync | None = None

PerAxisQuantization(axis: int, scales: tuple[float, ...], zero_points: tuple[int, ...]) -> None

dataclass

API tier: experimental

axis: int

scales: tuple[float, ...]

zero_points: tuple[int, ...]

analyze_run_model_for_engine(path: str | Path, engine: EngineType | str) -> TypedFixtureModelAnalysis

Read a model’s public inputs and outputs as engine’s fixture integration admits them.

API tier: experimental

Parameters

Parameters of analyze_run_model_for_engine
Name	Type	Default	Description
`path`	`str \| Path`	Required	The ``.tflite`` model.
`engine`	`EngineType \| str`	Required	The engine the run builds with.

Returns

Returns of analyze_run_model_for_engine
Type	Description
`TypedFixtureModelAnalysis`	The same analysis as :func:`analyze_run_model`, after the engine has
`TypedFixtureModelAnalysis`	admitted the model.

Raises

Errors raised by analyze_run_model_for_engine
Type	Description
`ConfigError`	engine is not an engine name, the model is unreadable, or the engine does not admit the model.

FixtureTensor(
    name: str,
    index: int,
    dtype: str,
    shape: tuple[int, ...],
    quantization: PerTensorQuantization | PerAxisQuantization | None,
) -> None

dataclass

One named model input or output with its dtype, shape and quantization.

API tier: experimental

name: str

index: int

dtype: str

shape: tuple[int, ...]

quantization: PerTensorQuantization | PerAxisQuantization | None

size_bytes: int

FixtureIO(tensor: FixtureTensor, data: FixtureFile, role: FixtureRole = FixtureRole.SIGNAL) -> None

dataclass

One model input with its fixed bytes, or one output with its expected bytes.

API tier: experimental

tensor: FixtureTensor

data: FixtureFile

role: FixtureRole = FixtureRole.SIGNAL

FixtureOutput(tensor: FixtureTensor) -> None

dataclass

One complete output declaration, without a reference answer.

API tier: experimental

tensor: FixtureTensor

TypedFixtureModelAnalysis(
    inputs: tuple[FixtureTensor, ...],
    outputs: tuple[FixtureTensor, ...],
    has_float16: bool,
    analysis: ModelAnalysis,
    resolver: ResolverPlan,
    has_internal_state: bool = False,
    has_initializer: bool = False,
    subgraph_count: int = 1,
    resource_variable_count: int = 0,
) -> None

dataclass

A model’s public inputs and outputs in model order, with its graph facts.

API tier: experimental

inputs: tuple[FixtureTensor, ...]

outputs: tuple[FixtureTensor, ...]

has_float16: bool

analysis: ModelAnalysis

resolver: ResolverPlan

has_internal_state: bool = False

has_initializer: bool = False

subgraph_count: int = 1

resource_variable_count: int = 0

input_bytes: int

output_bytes: int

TypedFixture(
    model: FixtureFile,
    inputs: tuple[FixtureIO, ...],
    outputs: tuple[FixtureIO, ...] | tuple[FixtureOutput, ...],
) -> None

dataclass

Fixed input bytes and complete ordered outputs for a model.

Outputs are descriptors, or legacy FixtureIO references. Reference bytes are not needed for measurement; legacy identities remain unchanged.

API tier: experimental

model: FixtureFile

inputs: tuple[FixtureIO, ...]

outputs: tuple[FixtureIO, ...] | tuple[FixtureOutput, ...]

expected: FixtureFile | None

identity: str

verify() -> None

Machine-readable: run_inputs.json · run_inputs.md, complete and lossless.