Building Causal Systems for Autonomous Agents

# Illustrative sketch (not from the paper)
import torch

# Simple causal graph expressed as adjacency list
causal_graph = {
    "A": ["B"],  # A → B
    "B": ["C"],  # B → C
}

# Linear coefficients for each variable (placeholder values)
coeff = {"A": 1.0, "B": 2.0, "C": 3.0}


def intervene(graph, var, value):
    """Simulate an intervention do({var}=value) on the causal graph.
    Returns a dict of sampled values for all variables.
    """
    # Sample exogenous noise for each node
    noise = {v: torch.randn(1) for v in coeff}
    # Initialise the intervened variable
    vals = {var: torch.tensor([value])}
    # Topological order (hard‑coded for this tiny example)
    order = ["A", "B", "C"]
    for node in order:
        if node in vals:
            continue
        # Identify parents of the current node
        parents = [p for p, childs in graph.items() if node in childs]
        parent_sum = sum(vals[p] for p in parents) if parents else 0
        # Linear structural equation with noise
        vals[node] = coeff[node] * parent_sum + noise[node]
    return vals

# Counterfactual query: what happens if we set A=1?
counterfactual = intervene(causal_graph, "A", 1.0)
print(counterfactual)

# Example of a causality‑powered loss that masks out non‑causal connections

def causal_loss(pred, target, mask):
    """Compute loss only on edges permitted by the causal mask.
    pred, target: tensors of the same shape
    mask: binary tensor where 1 indicates a causal relationship
    """
    return ((pred - target) * mask).abs().mean()

// Illustrative sketch (not from the paper)
const tf = require('@tensorflow/tfjs-node');

// Simple causal graph as adjacency list
const causalGraph = {
  A: ['B'], // A → B
  B: ['C'], // B → C
};

// Linear coefficients (placeholder values)
const coeff = { A: 1.0, B: 2.0, C: 3.0 };

/**
 * Simulate an intervention do(var = value) on the causal graph.
 * Returns a map of sampled values for all variables.
 */
function intervene(graph, variable, value) {
  // Sample exogenous noise for each node
  const noise = {};
  Object.keys(coeff).forEach(v => {
    noise[v] = tf.randomNormal([1]);
  });

  // Initialise intervened variable
  const vals = {};
  vals[variable] = tf.tensor([value]);

  // Hard‑coded topological order for this tiny example
  const order = ['A', 'B', 'C'];
  order.forEach(node => {
    if (vals[node]) return; // already set by intervention
    // Find parents of the node
    const parents = Object.entries(graph)
      .filter(([, childs]) => childs.includes(node))
      .map(([parent]) => parent);
    const parentSum = parents.length
      ? tf.addN(parents.map(p => vals[p]))
      : tf.scalar(0);
    // Linear structural equation with noise
    vals[node] = tf.add(tf.mul(coeff[node], parentSum), noise[node]);
  });
  return vals;
}

// Counterfactual query: set A = 1
const cf = intervene(causalGraph, 'A', 1.0);
console.log('Counterfactual values:', cf);

/**
 * Causality‑aware loss that masks out non‑causal connections.
 * pred, target: tf.Tensor of same shape
 * mask: tf.Tensor with 1 where causal, 0 elsewhere
 */
function causalLoss(pred, target, mask) {
  return tf.mean(tf.abs(tf.mul(tf.sub(pred, target), mask)));
}