Selecting Better Training Data for Agents

# Illustrative sketch (not from the paper)
import torch
import hdbscan
from qwen3_embedding import embed_text  # placeholder for Qwen3-Embedding-8B

# 1. Load trajectories (list of steps per issue)
trajectories = load_trajectories()  # each traj: {'issue': str, 'steps': [str]}

# 2. Encode issue descriptions for clustering
issue_embeddings = [embed_text(t['issue']) for t in trajectories]

# 3. Cluster trajectories with HDBSCAN
clusterer = hdbscan.HDBSCAN(min_cluster_size=5)
labels = clusterer.fit_predict(issue_embeddings)

# 4. Select high‑quality trajectories (e.g., label != -1)
selected = [t for t, lbl in zip(trajectories, labels) if lbl != -1]

# 5. Semantic segment chunking (boundary‑aware sliding window)
def chunk_segments(steps, win=3, stride=1):
    segs = []
    for i in range(0, len(steps) - win + 1, stride):
        segs.append(steps[i:i+win])
    return segs

# 6. Score each segment (placeholder scoring function)
def score_segment(seg):
    # contribution, learnability, risk – mocked as a scalar
    return compute_quality_score(seg)

# 7. Prepare SFT data: retain all segments as context, but compute loss only on high‑score ones
train_data = []
for traj in selected:
    segments = chunk_segments(traj['steps'])
    scores = [score_segment(s) for s in segments]
    high_quality = [s for s, sc in zip(segments, scores) if sc > QUALITY_THRESHOLD]
    train_data.append({'context': segments, 'target': high_quality})

# 8. Simple SFT loop (PyTorch)
model = load_model('GLM-4.7-Flash')
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-5)
for epoch in range(3):
    for item in train_data:
        optimizer.zero_grad()
        loss = model.compute_loss(context=item['context'], target=item['target'])
        loss.backward()
        optimizer.step()

// Illustrative sketch (not from the paper)
const torch = require('torch-js'); // placeholder for PyTorch‑like API
const hdbscan = require('hdbscan-js'); // placeholder library
const { embedText } = require('qwen3-embedding'); // placeholder for Qwen3-Embedding-8B

// 1. Load trajectories (array of {issue, steps})
const trajectories = loadTrajectories();

// 2. Encode issue descriptions
const issueEmbeddings = trajectories.map(t => embedText(t.issue));

// 3. Cluster with HDBSCAN
const clusterer = new hdbscan.HDBSCAN({ minClusterSize: 5 });
const labels = clusterer.fitPredict(issueEmbeddings);

// 4. Keep trajectories with a valid cluster label
const selected = trajectories.filter((_, i) => labels[i] !== -1);

// 5. Semantic segment chunking (sliding window)
function chunkSegments(steps, win = 3, stride = 1) {
  const segs = [];
  for (let i = 0; i <= steps.length - win; i += stride) {
    segs.push(steps.slice(i, i + win));
  }
  return segs;
}

// 6. Placeholder segment scoring
function scoreSegment(seg) {
  // returns a scalar quality score
  return computeQualityScore(seg);
}

// 7. Build training examples
const trainData = selected.map(traj => {
  const segments = chunkSegments(traj.steps);
  const scores = segments.map(scoreSegment);
  const highQuality = segments.filter((s, idx) => scores[idx] > QUALITY_THRESHOLD);
  return { context: segments, target: highQuality };
});

// 8. Simple SFT loop (using a mock torch model)
const model = loadModel('GLM-4.7-Flash');
const optimizer = new torch.optim.AdamW(model.parameters(), { lr: 1e-5 });
for (let epoch = 0; epoch < 3; epoch++) {
  for (const item of trainData) {
    optimizer.zeroGrad();
    const loss = model.computeLoss({ context: item.context, target: item.target });
    loss.backward();
    optimizer.step();
  }
}