Lowering Grading Costs with Rubric Anchoring

# Illustrative sketch (not from the paper)
import torch

# Placeholder for a frontier model (e.g., GPT-5.6 Sol)
frontier_model = "gpt-5.6-sol"

# Ingestion: extract question, rubric, and official answer from source docs
def ingest(source_docs):
    # In real use, call the frontier model with high reasoning effort
    extracted = []
    for doc in source_docs:
        # mock extraction structure
        extracted.append({
            "question": doc["question"],
            "rubric": doc["rubric"],
            "official_answer": doc["reference"]
        })
    return extracted

# Grading: apply rubric with a low‑cost small model (e.g., Claude Sonnet 5)
small_model = torch.nn.Linear(10, 1)  # dummy low‑cost model

def grade(rubric, student_answer):
    # Convert rubric & answer to tensors (placeholder)
    features = torch.randn(1, 10)  # mock feature vector
    score = small_model(features).item()
    # In practice, score would be computed by matching rubric criteria
    return max(0, min(100, round(score * 10)))  # clamp to 0‑100

# Example workflow
source_documents = [
    {"question": "Q1", "rubric": {"criterion": "clarity"}, "reference": "Official answer"},
    {"question": "Q2", "rubric": {"criterion": "accuracy"}, "reference": "Official answer"}
]
extracted_items = ingest(source_documents)
student_answers = ["Student answer 1", "Student answer 2"]
for item, ans in zip(extracted_items, student_answers):
    s = grade(item["rubric"], ans)
    print(f"Score for {item['question']}: {s}")

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

// Placeholder frontier model identifier
const frontierModel = 'gpt-5.6-sol';

// Ingestion: extract question, rubric, and official answer
function ingest(sourceDocs) {
  const extracted = [];
  for (const doc of sourceDocs) {
    extracted.push({
      question: doc.question,
      rubric: doc.rubric,
      officialAnswer: doc.reference
    });
  }
  return extracted;
}

// Low‑cost small model (dummy linear layer)
const smallModel = {
  forward: (features) => {
    // mock scoring logic
    return Math.random(); // returns a value in [0,1)
  }
};

function grade(rubric, studentAnswer) {
  // Convert rubric & answer to feature vector (placeholder)
  const features = torch.randn([1, 10]); // mock tensor
  const rawScore = smallModel.forward(features);
  const score = Math.max(0, Math.min(100, Math.round(rawScore * 1000) / 10)); // clamp 0‑100
  return score;
}

// Example workflow
const sourceDocuments = [
  { question: 'Q1', rubric: { criterion: 'clarity' }, reference: 'Official answer' },
  { question: 'Q2', rubric: { criterion: 'accuracy' }, reference: 'Official answer' }
];
const extracted = ingest(sourceDocuments);
const studentAnswers = ['Student answer 1', 'Student answer 2'];
extracted.forEach((item, idx) => {
  const s = grade(item.rubric, studentAnswers[idx]);
  console.log(`Score for ${item.question}: ${s}`);
});