Graph message passing, edge direction and self state

Define the prediction unit

A service dependency graph has service nodes and directed calls: checkout calls billing, billing calls a ledger, and an incident may affect any of them. First decide whether the target is a service state, a call failure or a whole-incident label. A node model emits one result per service. A link model scores pairs. Pooling node states produces a graph-level result. Their training labels and review units differ. Pixel-level prediction has a similar requirement: match output units to annotation units before choosing a loss.

Write the edge convention down

If an edge is stored as caller to callee, aggregation toward the destination carries information from callers to callees. Incident propagation may instead require the reverse direction, or two distinct relation types. A supposedly undirected graph is usually represented by both directed edges. Test a three-node example by hand. A silent edge reversal can preserve tensor shapes and training loss while changing the operational claim. Record whether duplicate calls are collapsed or weighted, and whether self loops are explicit.

Aggregate without degree surprises

Summing incoming messages scales with node degree; averaging makes a node with two similar callers comparable to one with twenty. Neither is always correct. A busy shared service may need degree as a feature because traffic itself matters. Include the node’s own state through a self loop or a separate transform, then combine it with neighbor messages. An isolated node should still retain its own features rather than produce an undefined mean. The code uses self-inclusive averaging so its result can be checked without a graph library.

Keep feature and edge clocks aligned

At an alert time, use metrics and calls observed by that time. A service graph assembled from the entire later incident can expose the answer through edges added after the alert. Attach valid-from and valid-to times to dependencies, and declare how long telemetry is delayed. A graph learner can also memorize service identity if train and test share the same nodes. The split lesson separates transductive and newly introduced services.

Probe the model against simpler rules

Compare a graph layer with a local-feature baseline and a hand-coded upstream/downstream summary. Ablate edges, flip their directions and remove high-degree hubs; measure which incident classes change. Inspect a few message paths rather than treating attention or embedding magnitude as proof of causality. If the graph model wins only when future edges are present, the result is leakage. The applied project includes that failure test.

Implementation

service_pressure = {"checkout": 8.0, "billing": 4.0, "inventory": 2.0}
calls = [("checkout", "billing"), ("checkout", "inventory")]

def self_and_caller_mean(features, directed_calls):
    incoming = {service: [pressure] for service, pressure in features.items()}
    for caller, callee in directed_calls:
        if caller not in features or callee not in features:
            raise ValueError("edge references an unknown service")
        incoming[callee].append(features[caller])
    return {service: sum(values) / len(values)
            for service, values in incoming.items()}

updated_pressure = self_and_caller_mean(service_pressure, calls)
assert updated_pressure == {"checkout": 8.0, "billing": 6.0,
                            "inventory": 5.0}

Performance and operating cost

One aggregation pass over V nodes and E directed edges costs O(V + E) time and O(V + E) temporary storage in this list-based demonstration. A dense V-by-V adjacency matrix costs O(V²) space even when the call graph is sparse. A learned layer also stores feature-width activations for backward; stacking L layers expands the information horizon to L hops and can make representations less distinct. Measure edge count, degree skew and per-layer memory before adding depth.

Common Mistakes

• Do not assume a caller-to-callee edge sends information in both directions.
• Do not divide by zero for isolated nodes or discard their self features.
• Do not infer causality from a large message weight without a timing and ablation check.

Read next

• Graph neighbor sampling and time-safe evaluation
• Project: attribute service incidents with a time-safe graph
• Project: segment clipped edges and folds on receipts
• Occlusion attribution and explanation sanity checks
• Inference contracts: preserve preprocessing and measure tail latency