Struct GraphSession 

pub struct GraphSession { /* private fields */ }

The primary orchestrator: Graph + catalog + cache + events.

let mut lib = NodeCatalog::new();
lib.register("scaler", Box::new(MyScaler::new()));
lib.register("model", Box::new(MyModel::new()));

let mut session = GraphSession::new(graph, lib);
session.fit(&train_x, Some(&train_y))?;
let output = session.forward(&test_x)?;

Implementations

impl GraphSession

pub fn new(graph: Graph, catalog: NodeCatalog) -> Self

A session over graph with an in-memory cache and its own event bus; the with_* builders swap in shared or persistent components.

pub fn with_cache(self, cache: Arc<dyn CacheStore>) -> Self

Replace the default in-memory cache, e.g. with a tiered or persistent store shared across sessions.

pub fn with_event_bus(self, bus: Arc<EventBus>) -> Self

Replace the session’s own event bus, e.g. with one a tracker is already subscribed to.

pub fn with_data_store(self, store: Arc<dyn DataStore>) -> Self

Attach the data store batched forward passes read rows from.

pub fn with_transports(self, transports: Vec<Arc<dyn Transport>>) -> Self

Attach one transport per worker, so a TrainingStrategy can run.

Without this, setting a strategy on a graph records it and nothing more — which is what it did for the whole life of the type. fit consults the graph’s strategy and, when it is not Local and transports are present, hands execution to StrategyExecutor.

pub fn with_worker_identities(self, identities: Vec<WorkerIdentity>) -> Self

Name the workers behind the transports, in the same order.

Needed only by ModelParallel, whose partitions are pinned to a worker id or tag. Without it that strategy refuses rather than sending a partition to whichever worker happened to be first.

pub fn with_transport(self, transport: Arc<dyn Transport>) -> Self

Attach the transport that carries Remote plan nodes to workers.

pub fn with_driver(self, driver: EffectDriver) -> Self

Attach the effect driver a graph containing steps needs.

The session clones the driver per run and hands it the catalog at that moment, so filters or steps registered through Self::catalog_mut after this call still count. Without a driver, executing a step keeps failing with the executor’s own explanation.

pub fn compile(&self, mode: CompileMode) -> Result<CompileResult>

Compile the graph and return diagnostics without executing.

pub fn run(&mut self, mode: CompileMode) -> Result<HashMap<String, Value>>

Compile and execute the graph, returning all node outputs.

Emits a RunStarted/RunCompleted (or RunFailed) bracket around the node events so readers can compute total duration and group the run.

pub fn fit( &mut self, x: &Value, y: Option<&Value>, ) -> Result<HashMap<String, Value>>

Fit all trainable filters in topological order. Delegates to LocalRunner — same execution path as remote workers.

Emits a RunStarted/RunCompleted (or RunFailed) bracket tagged with the same run id as the node events inside it.

pub fn forward_with( &self, x: &Value, strategy: &dyn ForwardStrategy, ) -> Result<Value>

Forward pass using the given strategy.

Strategies define HOW data flows through the compiled graph:

• crate::forward::Standard — full input at once with inference caching (default)
• crate::forward::Stream — chunked input through StreamExecutor
• crate::forward::Batched — rows from DataStore, batch by batch

pub fn forward(&self, x: &Value) -> Result<Value>

Standard forward pass (shortcut for forward_with(x, &Standard)).

pub fn persist_states(&self) -> Result<DataRef>

Persist all trained states to the data store.

pub fn load_states(&mut self, data_ref: &DataRef) -> Result<()>

Load previously persisted states from a data store reference.

pub fn subscribe(&self) -> Receiver<Event>

Subscribe to execution events.

pub fn event_bus(&self) -> &Arc<EventBus>

Access the event bus directly.

pub fn is_fitted(&self) -> bool

Whether the session has been fitted.

pub fn graph(&self) -> &Graph

Access the graph.

pub fn catalog(&self) -> &NodeCatalog

Access the node catalog.

pub fn catalog_mut(&mut self) -> &mut NodeCatalog

Mutable access to the node catalog (for registering nodes after creation).