CompiledFunction

A callable whose first call serves the eager result and records the graph; later calls with the same input structure and matching shapes run the graph without calling Python.

Made by :func:compile. The call takes and returns pytrees: tensor leaves feed the graph, every other leaf is a static value baked into the capture, so a call whose structure or static values differ from the capture re-captures (one capture per structure is kept, the oldest dropped past a small count). Shapes are the graph's own guard: a call whose shapes drift from a static capture serves eagerly and re-captures with the drifted axes dynamic; past a small budget of re-captures the function serves eagerly until :meth:reset.

state reports the current capture (State.Pending, State.Compiled or State.Fallback), recapture_count how many times a guard miss or a shape drift forced a new capture, and :meth:take_graph hands out the captured graph.

input_names (property)

The graph input names of the current capture, in flattening order.

recapture_count (property)

How many times a changed input structure, a changed static value, or drifted shapes forced a new capture.

state (property)

Where the current capture is in its lifecycle: State.Pending (nothing captured yet), State.Compiled (the graph serves matching calls) or State.Fallback (serving eagerly until :meth:reset).

State

State(*values)

Where the function is in its capture lifecycle: Pending (no graph yet), Compiled (a captured graph serves shape-matching calls), Fallback (the function serves eagerly and will not re-capture on its own).

__init__

__init__(self, target: 'Callable[P, R]', *, signature: 'Sequence[TensorSpec]' = (), dynamic: 'bool | None' = None, fullgraph: 'bool' = False, optimize: 'bool | None' = None, specialize: 'bool | None' = None, place: 'PlaceLike' = None, dynamic_axes: 'DynamicAxes | None' = None, output_names: 'Sequence[str] | None' = None, graph_name: 'str | None' = None) -> 'None'

Initialize self. See help(type(self)) for accurate signature.

reset

reset(self) -> 'None'

reset() -> None

Drop every capture and the re-capture count; the next call captures again.

take_graph

take_graph(self) -> 'object'

take_graph() -> ModelGraph

Take the captured graph out of the current capture (State.Compiled only); the function then serves eagerly until :meth:reset.