Optimizing Evidence Retrieval for Generative Search

# Illustrative sketch (not from the paper)
import torch
from torch.nn import functional as F

def causal_loo_probe(model, docs, query):
    # teacher‑forced forward pass on full context
    base_logits = model(query, context=docs)
    attributions = []
    for i, doc in enumerate(docs):
        # leave‑one‑out context
        loo_context = docs[:i] + docs[i+1:]
        loo_logits = model(query, context=loo_context)
        # attribution as KL divergence change (placeholder)
        delta = F.kl_div(base_logits, loo_logits, reduction='batchmean')
        attributions.append(delta.item())
    return attributions

def induce_facets(docs, embedder):
    # obtain sentence embeddings and extract semantic facets (placeholder)
    embeddings = embedder.encode(docs)  # shape [N, D]
    # simple selection of first few embeddings as facet prototypes
    centroids = embeddings[:3]
    return centroids

def submodular_scheduler(attributions, docs, budget):
    selected = []
    while len(selected) < budget:
        # greedy pick highest marginal gain (attribution) ignoring already selected
        gains = [a for idx, a in enumerate(attributions) if idx not in selected]
        idx = gains.index(max(gains))
        selected.append(idx)
    return [docs[i] for i in selected]

def contrastive_decode(model, query, selected_docs, apc):
    # generate logits conditioned on selected context
    logits = model(query, context=selected_docs)
    # apply a contrastive penalty bounded by an adaptive‑plausibility constraint (APC)
    penalty = torch.tensor(apc)
    adjusted = logits - penalty
    token = torch.argmax(F.softmax(adjusted, dim=-1), dim=-1)
    return token

# ----- Example usage (placeholders) -----
model = ...          # LLM instance
embedder = ...       # sentence‑embedding encoder
query = "..."
docs = ["doc1", "doc2", "doc3", "doc4"]
atts = causal_loo_probe(model, docs, query)
facets = induce_facets(docs, embedder)
selected = submodular_scheduler(atts, docs, budget=2)
answer = contrastive_decode(model, query, selected, apc=0.1)

// Illustrative sketch (not from the paper)
const torch = require('torch-js'); // placeholder for tensor ops

function causalLooProbe(model, docs, query) {
  // teacher‑forced forward pass on full context
  const baseLogits = model.forward(query, { context: docs });
  const attributions = [];
  docs.forEach((doc, i) => {
    const looContext = docs.slice(0, i).concat(docs.slice(i + 1));
    const looLogits = model.forward(query, { context: looContext });
    // attribution as KL divergence change (placeholder)
    const delta = torch.nn.functional.klDiv(baseLogits, looLogits, { reduction: 'batchMean' });
    attributions.push(delta.item());
  });
  return attributions;
}

function induceFacets(docs, embedder) {
  // obtain sentence embeddings and pick prototype facets (placeholder)
  const embeddings = embedder.encode(docs); // shape [N, D]
  const centroids = embeddings.slice(0, 3); // first three as facets
  return centroids;
}

function submodularScheduler(attributions, docs, budget) {
  const selected = [];
  while (selected.length < budget) {
    // greedy selection of highest marginal gain
    const gains = attributions.filter((_, idx) => !selected.includes(idx));
    const maxGain = Math.max(...gains);
    const idx = attributions.indexOf(maxGain);
    selected.push(idx);
  }
  return selected.map(i => docs[i]);
}

function contrastiveDecode(model, query, selectedDocs, apc) {
  // generate logits conditioned on selected context
  const logits = model.forward(query, { context: selectedDocs });
  // apply contrastive penalty bounded by adaptive‑plausibility constraint
  const penalty = torch.tensor(apc);
  const adjusted = torch.sub(logits, penalty);
  const probs = torch.nn.functional.softmax(adjusted, -1);
  const token = torch.argmax(probs, -1);
  return token;
}

// ----- Example usage (placeholders) -----
const model = /* LLM instance */ null;
const embedder = /* sentence encoder */ null;
const query = "...";
const docs = ["doc1", "doc2", "doc3", "doc4"];
const atts = causalLooProbe(model, docs, query);
const facets = induceFacets(docs, embedder);
const selected = submodularScheduler(atts, docs, 2);
const answer = contrastiveDecode(model, query, selected, 0.1);