Improving Long Horizon Remote Sensing Reasoning

# Illustrative sketch (not from the paper)
import torch
from torch.utils.data import DataLoader
# Placeholder imports for the vision-language model and dataset
from model import Qwen2_5_VL_7B  # assumed wrapper
from dataset import LongEarthBench  # provides (frames, question, answer, seq_id)

# Load base model
model = Qwen2_5_VL_7B.from_pretrained('qwen2.5-vl-7b')
model.train()

# Prepare data loader for supervised fine‑tuning (SFT)
train_dataset = LongEarthBench(split='train')
loader = DataLoader(train_dataset, batch_size=4, shuffle=True)

optimizer = torch.optim.AdamW(model.parameters(), lr=1e-5)

for epoch in range(1):  # single epoch illustration
    for frames, question, answer, seq_id in loader:
        # frames: list of image tensors for a sequence
        # seq_id: explicit identifier for each frame (grounding)
        # Forward pass with chain‑of‑thought supervision
        logits = model(frames, question, seq_id)
        loss = torch.nn.functional.cross_entropy(logits, answer)
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

# ---- Group Relative Policy Optimization (GRPO) ----
# Define simple reward functions (placeholders)
def reward_format(output):
    return 1.0 if output.startswith('Answer:') else 0.0

def reward_temporal(output, seq_id):
    # reward if temporal references match seq_id (mock)
    return 1.0

def reward_spatial(output, frames):
    # reward if spatial terms align with frame content (mock)
    return 1.0

# Mock policy‑gradient step
for frames, question, _, seq_id in DataLoader(train_dataset, batch_size=1):
    output = model.generate(frames, question, seq_id)
    r = reward_format(output) + reward_temporal(output, seq_id) + reward_spatial(output, frames)
    # Compute policy loss (negative reward * log prob) – placeholder
    log_prob = model.log_prob(output, frames, question, seq_id)
    policy_loss = -r * log_prob.mean()
    policy_loss.backward()
    optimizer.step()
    optimizer.zero_grad()

// Illustrative sketch (not from the paper)
const torch = require('torch-js'); // placeholder for PyTorch-like API
const { Qwen2_5_VL_7B } = require('./model'); // assumed wrapper
const { LongEarthBench } = require('./dataset'); // provides frames, question, answer, seqId

// Load base model
const model = Qwen2_5_VL_7B.fromPretrained('qwen2.5-vl-7b');
model.train();

// Prepare data loader for supervised fine‑tuning (SFT)
const trainDataset = new LongEarthBench('train');
const loader = new torch.utils.data.DataLoader(trainDataset, { batchSize: 4, shuffle: true });

const optimizer = new torch.optim.AdamW(model.parameters(), { lr: 1e-5 });

(async () => {
  // SFT loop (single epoch illustration)
  for await (const batch of loader) {
    const { frames, question, answer, seqId } = batch; // seqId: explicit frame identifiers
    const logits = model.forward(frames, question, seqId);
    const loss = torch.nn.functional.crossEntropy(logits, answer);
    loss.backward();
    optimizer.step();
    optimizer.zeroGrad();
  }

  // ---- Group Relative Policy Optimization (GRPO) ----
  const rewardFormat = (output) => (output.startsWith('Answer:') ? 1.0 : 0.0);
  const rewardTemporal = (output, seqId) => 1.0; // placeholder
  const rewardSpatial = (output, frames) => 1.0; // placeholder

  // Mock policy‑gradient step
  const policyLoader = new torch.utils.data.DataLoader(trainDataset, { batchSize: 1 });
  for await (const batch of policyLoader) {
    const { frames, question, seqId } = batch;
    const output = model.generate(frames, question, seqId);
    const r = rewardFormat(output) + rewardTemporal(output, seqId) + rewardSpatial(output, frames);
    const logProb = model.logProb(output, frames, question, seqId);
    const policyLoss = torch.neg(r).mul(logProb.mean());
    policyLoss.backward();
    optimizer.step();
    optimizer.zeroGrad();
  }
})();