Selecting Better Training Data for Agents

# Illustrative sketch (not from the paper)
import torch
import hdbscan
from qwen3_embedding import Qwen3Embedding8B  # placeholder import
from glm import GLM4_7Flash  # placeholder import

# 1. Encode issue descriptions (SWE‑Bench trajectories) with Qwen3‑Embedding‑8B

def encode_issues(issues):
    embedder = Qwen3Embedding8B()
    return embedder.encode(issues)  # -> Tensor[N, D]

# 2. Trajectory‑level screening using HDBSCAN clustering on the embeddings

def trajectory_screening(traj_embeddings):
    clusterer = hdbscan.HDBSCAN(min_cluster_size=5)
    labels = clusterer.fit_predict(traj_embeddings)
    # keep trajectories belonging to dense, high‑quality clusters (label >= 0)
    return [i for i, l in enumerate(labels) if l >= 0]

# 3. Segment‑level selection (placeholder heuristics for contribution & risk)

def segment_selection(segments):
    selected = []
    for idx, seg in enumerate(segments):
        if seg["contribution"] > 0.5 and seg["risk"] < 0.3:
            selected.append(idx)
    return selected

# 4. Boundary‑aware chunking to avoid splitting semantic segments

def boundary_aware_chunk(segments, max_len=512):
    chunks, cur, cur_len = [], [], 0
    for seg in segments:
        seg_len = len(seg["tokens"])
        if cur_len + seg_len > max_len:
            chunks.append(cur)
            cur, cur_len = [], 0
        cur.append(seg)
        cur_len += seg_len
    if cur:
        chunks.append(cur)
    return chunks

# 5. Selective SFT: all segments are context, loss only on selected ones

def selective_sft(model, chunks, selected_idxs):
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)
    for chunk in chunks:
        # flatten tokens for the whole chunk (context)
        inputs = torch.tensor([t for seg in chunk for t in seg["tokens"]])
        outputs = model(inputs)
        # mask loss to selected segments only
        mask = torch.zeros_like(outputs.logits, dtype=torch.bool)
        offset = 0
        for i, seg in enumerate(chunk):
            seg_len = len(seg["tokens"])
            if i in selected_idxs:
                mask[offset:offset+seg_len] = True
            offset += seg_len
        loss = torch.nn.functional.cross_entropy(outputs.logits[mask], inputs[mask])
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

// Illustrative sketch (not from the paper)
const torch = require('torch-js'); // placeholder for PyTorch in Node
const hdbscan = require('hdbscan-js'); // placeholder clustering lib
const { Qwen3Embedding8B } = require('qwen3-embedding'); // placeholder
const { GLM4_7Flash } = require('glm-model'); // placeholder

// 1. Encode issue descriptions with Qwen3‑Embedding‑8B
function encodeIssues(issues) {
  const embedder = new Qwen3Embedding8B();
  return embedder.encode(issues); // returns Tensor[N, D]
}

// 2. Trajectory‑level screening via HDBSCAN
function trajectoryScreening(trajEmbeddings) {
  const clusterer = new hdbscan.HDBSCAN({ minClusterSize: 5 });
  const labels = clusterer.fitPredict(trajEmbeddings);
  // keep trajectories in dense clusters (label >= 0)
  return labels.map((l, i) => (l >= 0 ? i : -1)).filter(i => i !== -1);
}

// 3. Segment‑level selection (simple heuristics)
function segmentSelection(segments) {
  const selected = [];
  segments.forEach((seg, idx) => {
    if (seg.contribution > 0.5 && seg.risk < 0.3) selected.push(idx);
  });
  return selected;
}

// 4. Boundary‑aware chunking
function boundaryAwareChunk(segments, maxLen = 512) {
  const chunks = [];
  let cur = [], curLen = 0;
  for (const seg of segments) {
    const segLen = seg.tokens.length;
    if (curLen + segLen > maxLen) {
      chunks.push(cur);
      cur = [];
      curLen = 0;
    }
    cur.push(seg);
    curLen += segLen;
  }
  if (cur.length) chunks.push(cur);
  return chunks;
}

// 5. Selective SFT – all tokens are context, loss only on selected segments
async function selectiveSFT(model, chunks, selectedIdxs) {
  const optimizer = new torch.optim.Adam(model.parameters(), { lr: 1e-5 });
  for (const chunk of chunks) {
    const inputs = torch.tensor(chunk.flatMap(seg => seg.tokens));
    const outputs = model.forward(inputs);
    // build mask for loss computation
    const mask = torch.zerosLike(outputs.logits, { dtype: torch.bool });
    let offset = 0;
    chunk.forEach((seg, i) => {
      const segLen = seg.tokens.length;
      if (selectedIdxs.includes(i)) {
        mask.slice(offset, offset + segLen).fill(true);
      }
      offset += segLen;
    });
    const loss = torch.nn.functional.crossEntropy(outputs.logits.maskedSelect(mask), inputs.maskedSelect(mask));
    loss.backward();
    optimizer.step();
    optimizer.zeroGrad();
  }
}