GeoX: Mastering Geospatial Reasoning Through Self-Play and Verifiable Rewards
arXiv:2605.20006v1 [cs.AI] 19 May 2026
Kyeongjin Ahn KAIST MPI-SP
Seungeon Lee MPI-SWS
Krishna P. Gummadi MPI-SWS
Meeyoung Cha MPI-SP
Abstract Geospatial reasoning requires solving image-grounded problems over the complex spatial structure of a scene. However, developing this capability is hindered by the cost of annotating a vast and combinatorial question space. We propose GeoX, a self-play framework that acquires spatial logic through executable programs that yield verifiable rewards, without relying on large-scale human-curated data Given a satellite or aerial image, our framework employs a single multimodal policy that proposes spatial problems as executable programs and solves them under three reasoning modes—abduction, deduction, and induction—over spatial primitives and an image understanding tool. A verifier executes each program to covert a reward signal that jointly optimizes the two roles via reinforcement learning. GeoX consistently improves its base VLMs by up to 5.5 points on average, matching or exceeding conventional baselines trained on millions of curated data. Alongside the proposed method, we release a benchmark for geospatial understanding accumulated through self-play.
1
Introduction
Interpreting the complex Earth’s surface from high-resolution satellite and aerial imagery is a central challenge in remote sensing, with broad implications for urban planning [1, 2, 4, 12], environmental monitoring [27, 21], and disaster response [9, 3]. As such imagery proliferates at unprecedented scale, these capabilities are becoming a strategic necessity. Many practical questions like “which buildings lie closest to the planned metro station?” cannot be answered by recognizing what is present in an image alone. They instead demand a structured understanding of how objects interact, including their arrangement, adjacency, and relations across the scene. Standard tasks such as scene classification, object detection, and image captioning characterize the contents, but not its underlying spatial structure of a scene. Geospatial reasoning over this structure is thus a core capability for real-world deployment. Specialized vision-language models (VLMs) for remote sensing have advanced significantly, but their geospatial understanding is bottlenecked by their supervision regime [11, 10, 29]. These models depend on fine-tuning over human-curated question–answer pairs, while the space of spatial questions explodes combinatorially with the many objects in each overhead image. For example, valid questions within an urban image already grow jointly with the target, the reference, and the property among its hundreds of objects, placing comprehensive coverage beyond the reach of manual annotation. As a result, existing datasets span only a small fraction of this space, leaving the models bounded by the scope of human curation (Figure 1a). Preprint.
or
AI
A. Programmatically Verified
Python
Existence Quantity Coverage Comparison Category Relation Scene Direction Overlap etc 7B
Qwen-2.5-VL 4B
real
7B
Accuracy (%)
9B
GeoX (Ours)
LLaVA-1.5
GLM-4.1
InternVL2
Conventional Work: Human-curated QA
real
Human-designed Questions Template : <Q> about <object>? sPrompt :> Generate <Q> with <label>.
7B
dss
Qwen-2.5-VL VHM RSThinker 7B LLaVA-1.5 7B
Q. “ Are there <buildings>? ” Q. “ How many <vehicles> are? ”
A. Externally Annotated (e.g., Human, Frontier VLMs) EarthDial
9B
4B
GeoChat 7B
The number of curated training data
Existence Quantity Coverage Comparison Category Relation Scene Direction Overlap …
(a) Performance on VQA benchmarks
GeoX: Self-play QA Model-generated Questions
Q. “ Is the largest land-use area greater than the building area? ”
Self-play
Q. “ Which quadrant has the nearest parking lot to buildings? ” A. Programmatically Verified
(b) Paradigm comparison
Figure 1: Standing and motivation. (a) GeoX outperforms prior VLMs on VQA benchmarks while using zero curated training data; (b) Conventional work derives questions from human-designed templates with answers externally annotated, confining them to predefined patterns. Our framework replaces this paradigm with autonomous self-play, where a single model proposes questions whose answers are programmatically verified, broadening them to compositional patterns.
Our key insight is that imagery itself encodes the spatial structure that enables its own interpretation. Tasks involving area, centroid, distance, or adjacency reduce to discrete geometric and topological operations whose answers are fixed by the image rather than left to model judgment. Composed into executable programs, these operations admit uniquely determined answers recoverable from the image alone. The supervision required for geospatial reasoning is therefore latent in the scene and accessible without external annotation. We propose a self-play framework GeoX for geospatial understanding (Figure 1b). A single model alternates between two roles, where a proposer that constructs an executable problem over the input image and a solver that finds its solution. Each problem specifies an executable program whose execution coverts a verifiable reward that jointly optimizes both roles via reinforcement learning, grounding the learning signal in the spatial structure of the image. To master a scene rather than merely answer about it, each problem is recast under three reasoning modes: abduction, deduction, and induction. Our contributions are as follows. • Self-play with verifiable rewards for geospatial reasoning. We adapt the self-play paradigm using proposer and solver to remote sensing imagery by routing perception into executable programs composed over a spatial primitives and an image understanding tool. A verifier turns each problem into a verifiable reward signal by program execution, letting the model internalize the geometric and topological structure of the Earth’s surface without curated data. • One proposal seen through three modes of reasoning. Each problem is recast under abduction, deduction, and induction, which mask a different element of the problem and elicit a different mode of interrogation: inferring the cause from observed evidence, predicting outcomes from a known cause, and synthesizing the procedure that connects them. One proposal can afford three complementary views of the same scene. • Strongest gains where curated supervision falls short. Across remote sensing benchmarks for visual question answering and object counting, our method matches or surpasses prior specialized VLMs, with the largest gains on counting and spatial relation tasks, precisely where the cost of curation becomes prohibitive. • A self-grown benchmark verified by program execution. From the self-play process, we automatically accumulate problems with execution-verified answers, ranging from simple to compositional relations. The resulting suite broadens existing remote sensing benchmarks, which skew toward presence detection and scene classification. This framework is a path toward learning the spatial physics of remote sensing imagery. By grounding optimization in executable programs, the framework moves beyond rote prediction toward structural 2
cab segmenter
e Sensing Images
…
: program
: argument
: output x
p(I, 𝐚 = o
Joint Update Policy Learnability Improvement
Policy xx
Correctness Improvement Model Input / Output
Model Reward program argument
output
Problem Banks problem triplet
Centroid
Call Interface
Proposer
Primitives Library
q: “Which quadrant has the most ships?”
Area
Centroid
Distance
Adjacent
Count
p(I, a): import numpy import segment m = segment(I, a) ... return o
Road Graph
Deduction
+
+
Induction +
?
? Infer
?
Predict
Sythesize
segmentation
Open-voca Segmenter Depth
Abduction
a = “ship”
Argmin
Tool Registry
Solver
Validity Check Verifier
Meta Data
?
=
Proposer Reward
Verifier
?
=
Verifier
?
=
Solver Reward
Figure 2: Method overview. A single multimodal policy πθ alternates between a proposer (middle) p(I, 𝒂) = o and a solver (right) that share a call interface (left) of spatial primitives F and tools T (instantiated here with an open-vocabulary segmenter; greyed entries left for future work). Conditioned on image I, the proposer construct a problem by composing calls into an executable program p paired with an argument a, forming (p, a, o) with o = p(a; I). The solver then recovers a masked element of the problem under three reasoning modes: abduction infers â, deduction predicts ô, and induction synthesizes p̂. The verifier calculates a proposer reward for problem learnability and a solver reward for answer correctness, which jointly update πθ . representations that capture inherent properties of the physical world. This aligns with emerging efforts to develop methods that acquire physical laws via self-improving.
2
The GeoX paradigm
2.1
Preliminaries
We establish the core mechanisms of reinforcement learning through self-play and verifiable rewards. Due to space constraints, a comprehensive review of additional relevant literature is provided in Appendix A. Reinforcement Learning with Verifiable Rewards (RLVR). In RLVR, a model generates a response y for a question x and scores it against a reference answer y ⋆ using a verifier via exact-match or program execution. Formally, it maximizes the expected reward over a dataset of question-answer pairs DRLVR = {(xn , yn⋆ )}N n=1 : JRLVR (θ) = E(x,y⋆ )∼DRLVR , y∼πθ (·|x) r(y, y ⋆ ) , (1) where πθ is the policy and r is a verifier reward (e.g., I[y = y ⋆ ]). This approach bypasses human preference labels and learned reward models, delivering a direct and stable feedback signal. Whereas supervised fine-tuning (SFT) teaches a model to imitate every token of a reference response, RLVR constrains it on only the final answer, leaving the intermediate reasoning trajectory free to be explored and refined. Self-play between proposer and solver Self-play enables a model to improve by posing and addressing its own problems. In one such setup, a proposer and a solver share parameters to form a closed learning cycle [31]. The proposer constructs an executable problem, the solver attempts to solve it, and a verifier executes the program to provide a reward that optimizes both roles. Each problem is represented as a triplet: (p, a, o), o = p(a), (2) 3
p(I, 𝐚) = p(I, a)
where p is an executable program, a is its input argument, and o is its output. We use three distinct reasoning modes by masking different elements of the triplet: In abduction, the solver infers a from (p, o). In deduction, it predicts o from (p, a). In induction, it synthesizes p from input-output examples {(at , ot )}t . Concretely, p is a program that counts ships of a specified type in a geospatial context. Here, abduction hypothesizes the type from an observed count (o = 7 → a = cargo); deduction derives the count from a given type (a = cargo → o = 7); induction generalizes p from input-output pairs ({(cargo, 7), (fishing, 3)} → p). One proposal thus affords three complementary perspectives on the same scene, each engaging a particular facet of spatial reasoning. 2.2
Problem setting
We refer to the proposed method as GeoX, which trains a single multimodal policy πθ on remote sensing imagery through self-play and verifiable rewards via program execution, as illustrated in Figure 2. The policy first acts as a proposer, constructing an executable problem that realizes a spatial question over an input image. It then acts as a solver, attempting to find the solution for constructed problems. Both roles are driven by verifiable rewards: the proposer is rewarded for devising challenging yet learnable problems, while the solver is rewarded for answering correctly under the three reasoning modes. Let I = {Im }M m=1 be a collection of unlabeled remote sensing images. The policy πθ returns an answer y to a spatial question q on an image I ∈ I. Each question is expressed as an image-grounded executable problem: (p, a, o, I), o = p(a; I), (3) where p is a program, a is its argument, and o is the output. For each image I, the proposer generates (p, a), whose execution determines o. The solver then completes a masked element of the problem from partial observations, depending on the reasoning mode. Proposer. We maintain three problem banks Dabd , Dded , and Dind corresponding to each reasoning mode. These banks offer in-context references for the proposer. In abduction and deduction, the proposer samples two image batches Babd = {Ibabd }B b=1 and Bded = ded B {Ib }b=1 . It constructs one executable problem per image I using K in-context references drawn from Dabd for abduction or Dded for deduction. Each problem consists of a question q, program p, and argument a, with output o obtained by p(a; I). Only valid constructions are used for growing the respective bank, while failed (e.g., syntax or runtime errors) or non-deterministic ones (e.g., randomness, file I/O) are discarded. In induction, the proposer samples B programs from Dabd ∪ Dded and generates Nio input-output io pairs {(at , ot )}N t=1 for each program using references from Dind . The same grow-and-discard rule is applied. Solver. The solver processes 3B total problems for three reasoning modes, where samples from each bank fill any shortfall in valid proposals. For each problem, the solver makes R attempts, yielding 3BR outputs per training step. In abduction, the solver infers the missing argument â from (I, p, o). In deduction, it predicts the expected output ô from (I, p, a). In induction, it discovers the io underlying program p̂ from (I, {(at , ot )}N t=1 ). The verifier scores each result in a mode-specific manner: ? Abduction: πθsolve â | I, p, o , o = p(â; I), (4) ? Deduction: πθsolve ô | I, p, a , ô = p(a; I), (5) X ? 1 Induction: πθsolve p̂ | I, {(at , ot )}t∈V , I ot = p̂(at ; I) . (6) |U| t∈U
Here, for induction, the Nio input-output pairs are split into a visible subset V and a held-out subset U, where V ∪ U = {1, . . . , Nio }. This requires the solver to reconstruct the program rather than memorize seen pairs. 4
Seed initialization. To initialize this process, we define a simple hand-written seed template that calls a segmentation function to check the presence of an object (e.g., "Is there a building?"), as shown in Figure 3. The template is instantiated by pairing random object phrases with images, populating each bank with Nseed problems. From this warm start, the proposer moves toward increasingly compositional problems, such as comparing areas across object categories, without further human intervention.
S EED P ROGRAM QUESTION q
"Is there a building?" ARGUMENT a
"building" PROGRAM p
2.3
Programs over image-grounded interface def f (I , a ):
from tools import segment The executor exposes two sets of callables: a primimport numpy as np itives library F and a tool registry T , with E = mask = segment (I , a ) F ∪ T as the full call interface. The primitives return bool ( np . any ( mask )) library F contains geometric operators (e.g., area, centroid, orientation) and topological operators OUTPUT o (e.g., distance, adjacent, overlaps), along with agTrue gregation operators (e.g., count, argmin, compare), implemented on top of NumPy, SciPy, and scikit-image. The tool registry T contains specialized modules for Figure 3: Seed problem. A segmenter call extracting structured information from the image. A with the phrase "building", followed by a spatial program composes callables from E, allowing presence check on the returned mask. primitives and tools to be interleaved as needed.
A minimal tool registry. For the experiments in this paper, we equip T with a single tool: an openvocabulary segmenter that maps an image paired with a natural-language phrase (e.g., "red-roofed building") to a set of segmentation masks. This minimal choice is motivated by three considerations. (1) Spatial sufficiency. Many spatial tasks considered in this work can be computed directly from segmentation masks using geometric, topological, and aggregation operators. (2) Open-vocabulary flexibility. Open-vocabulary segmenter accepts arbitrary phrases generated by the policy, so a single tool can support diverse spatial questions without committing to a fixed class vocabulary. (3) Methodological isolation. The single-tool usage isolates self-play’s contribution from that of a richer toolset, establishing a clean baseline against which future extensions can be evaluated. Intermediate values are hidden from the policy. The policy πθ accesses only I and the available calls in F and T . All intermediate values produced during execution remain internal to the executor and inaccessible to the policy. For example, when the policy issues a segmenter call with the phrase "solar panel array", neither the resulting mask array nor any values derived from it in subsequent calls such as count or area are exposed to the policy. This design prevents the policy from exploiting execution traces as shortcuts, forcing it to reason from the image and program specification instead. 2.4
Reward design
The proposer and solver are optimized jointly through a unified policy πθ with mutually informative rewards. Solver reward. The solver is rewarded for the correctness of its answers by a verifier. For abduction and induction, where the output is fully determined by program execution, the verifier is reduced to an execution-consistency condition that the returned output under the solver’s result exactly matches o: solve rabd (â) = I p(â; I) = o ,
solve rind (p̂) =
1 X I p̂(at ; I) = ot . |U| t∈U
5
(7)
For deduction, by contrast, where the output may take various types across problems, the type-aware verifier is adopted in place of a binary exact-match rule: max 0, 1 − |ô − o|/ max(|o|, 1) numeric, I[norm(ô) = norm(o)] string, solve rded (ô) = (8) I[ô = o] boolean, IoU(ô, o) bounding box. Proposer reward. The proposer is rewarded for the learnability [31] of its proposals. The learnability of a problem is estimated from R solver rollouts, by averaging their solver rewards: R
r̄solve =
1 X solve r , R i=1 (i)
(9)
which then defines the proposer reward: rprop = I r̄solve > 0 · 1 − r̄solve . solve
(10) solve
The reward vanishes at both extremes (r̄ ∈ {0, 1}) and peaks at r̄ = 1/2. An adaptive curriculum thus emerges, in which the proposer favors problems at the frontier of the solver’s ability, advancing as the solver improves Joint optimization.
The shared parameters θ are trained with a joint objective:
J GeoX (θ) = λ J prop (θ) + J solve (θ), (11) where J prop and J solve are the expected proposer and solver rewards under their problem distributions. We set λ = 1 in all experiments, weighting the two roles equally.
3
Experiments
3.1
Evaluation setup
Datasets. Geospatial understanding is evaluated on three VQA benchmarks: RSVQA-HR [16], EarthVQA [25], and GEOBench-VLM [6]. From GEOBench-VLM, we use the 17 out of 31 tasks that target spatial understanding. Baseline models. We compare our method against two groups of baselines. (i) Base: general-purpose VLMs evaluated zero-shot, namely Qwen-2.5-VL-7B-Instruct [26] (Qwen) and LLaVA-1.5-7B [14] (LLaVA). (ii) Conventional: domain-specific VLMs fine-tuned on human-curated remote sensing data, namely GeoChat [11], VHM [19], EarthDial [22], and RSThinker [15]. Evaluation procedure. Performance is measured using accuracy. Closed-form answers are scored by exact match, while open-ended answers are scored by an LLM-as-judge. For each question, we generate Neval = 32 responses and aggregate them by majority voting. Appendices B, C, and D, respectively. Further analyses on training dynamics and object counting are presented in Appendix E, and full results for Sections 3.2 and 3.3 are reported in Appendix I. 3.2
Main results
Table 1 reports the performance of GeoX against strong zero-shot and conventional remote sensing VLMs. Without any curated data, GeoX improves over its base models on average (+5.5 points for LLaVA, +1.9 points for Qwen), and GeoXQ attains the highest average on EarthVQA (51.2) and GEOBench-VLM (43.3), exceeding even EarthDial (trained on 11.1M curated pairs). The gains are most pronounced on tasks that fit naturally within our verifiable environment. For example, Area and Comparison on RSVQA-HR show substantial improvements, Spatial Relation Classification on GEOBench-VLM surpasses the strongest conventional baseline by over 7 points, and counting tasks benefit broadly across both base models, especially on EarthVQA and GEOBenchVLM. This pattern indicates that the current execution interface is effective for tasks grounded in geometric and relational structures. It also suggests that enriching the tool registry T is a promising direction for closing the remaining gaps. 6
Table 1: Main results on VQA benchmarks. Performance of GeoX, instantiated from two base VLMs (LLaVA and Qwen), is compared against six baselines on RSVQA-HR, EarthVQA, and the four task categories of GEOBench-VLM. For each model, the number of human-curated QA pairs used for fine-tuning is listed; baseline models fine-tuned on fully curated data are grey shaded. The best result in each row is shown in bold, and our results are highlighted in blue when they surpass the corresponding base (LLaVA or Qwen). Base Benchmark / Task
Conventional
Self-play
LLaVA
Qwen
GeoChat
VHM
EarthDial
RSThinker
GeoXL
GeoXQ
0
0
318K
1.4M
11.1M
380K
0
0
Presence Count Area Comparison
57.9 30.3 2.7 52.5
60.1 35.2 10.3 69.7
57.9 25.5 41.6 74.8
72.3 13.5 13.5 70.7
60.0 25.9 38.8 78.9
55.4 22.1 22.1 68.7
61.9 30.5 40.3 57.5
63.2 36.6 16.5 72.0
Average
35.9
43.8
50.0
42.5
50.9
42.1
47.6
47.1
Basic Judging Reasoning-based Judging Reasoning-based Counting Basic Counting Object Situation Analysis Comprehensive Analysis
78.6 55.8 24.8 60.6 28.2 19.6
78.0 73.0 23.4 62.4 29.4 33.6
66.6 37.0 16.6 26.0 2.2 7.8
79.0 71.8 12.8 39.6 23.2 24.6
76.2 41.4 5.6 53.0 4.0 11.0
69.4 42.6 15.4 45.8 25.2 19.0
82.2 53.8 33.8 70.2 30.4 19.5
78.2 68.6 26.6 69.4 30.2 34.4
Average
44.6
50.0
26.0
41.8
31.9
36.2
48.3
51.2
Object Localization & Counting Scene Understanding Object Classification Event Detection
20.6 46.6 35.2 14.7
37.3 54.8 43.8 45.3
22.2 49.6 34.5 37.8
27.0 55.1 36.3 47.0
24.8 60.5 35.9 16.7
24.7 49.6 36.2 20.9
22.2 47.1 36.5 14.3
39.5 53.9 47.5 42.4
Average
26.2
42.1
30.3
35.4
31.4
30.0
27.4
43.3
# Curated RSVQA-HR
EarthVQA
GEOBench-VLM
Table 2: Ablation study results on GEOBench-VLM. Performance is reported across the four task categories of GEOBench-VLM. Columns specify which solver modes are active: A (Abduction), D (Deduction), I (Induction). Singleton Variants keeps one mode; Drop-one Variants removes one; Training Variants use all three reasoning modes. Full denotes our default configuration. The best result in each row is shown in bold and the second-best is shown in underline. Training Variants
Full
Config. Active Modes
Abd A
Singleton Variants Ded D
Ind I
−Abd D,I
−Ded A,I
−Ind D,A
BaseGen D,A,I
SolvOnly D,A,I
GeoX D,A,I
Object Localization & Counting Scene Understanding Object Classification Event Detection
35.5 51.4 45.3 39.0
37.2 52.4 46.8 42.4
36.4 49.4 46.3 40.3
36.5 48.1 43.6 40.3
36.4 50.8 49.3 43.6
37.5 52.1 44.3 42.8
37.4 51.3 42.5 46.9
34.3 50.1 45.3 46.6
39.5 53.9 47.5 42.4
Average
39.9
41.6
40.3
39.8
41.3
41.5
41.6
39.8
43.3
3.3
Drop-one Variants
Ablation study
For ablation of the reasoning modes, we contrast the full model against Singleton variants (one mode keeped) and Drop-one variants (one mode removed). To examine the role of self-play, we further consider two training variants: (i) BaseGen, which replaces problems from self-play with those from the base model (Qwen-2.5-VL-7B-Instruct), and (ii) SolvOnly, which maintains the self-play mechanism but ignores the proposer reward and relies solely on solver-side reward signals. The former probes whether exposure to image data alone suffices without an evolving curriculum, whereas the latter tests whether the model can improve effectively without explicitly incentivizing the generation of "learnable" problems. 7
RSVQA-HR
EarthVQA
GEOBench-VLM
GeoX (Ours)
Figure 4: Pairwise dimension compositions across datasets. Each node represents one of nine question dimensions; node size reflects how often a dimension appears in a single problem, and edge thickness reflects how often two dimensions co-occur within a single problem. Query (q): “ In which quadrant (TL, TR, BL, BR) does the centroid of the largest ship lie in the image? ”
Image (I)
Segmentation
Argument (a): “ship” Program (p): def f(image, a): import numpy as np from scipy.ndimage import center_of_mass from tools import segment instances = segment(image, a) if not isinstance(instances, list) or not instances: return "none" largest = max(instances, key=lambda m: int(np.sum(m))) cy, cx = center_of_mass(largest) h, w = largest.shape return ("T" if cy < h / 2 else "B") + ("L" if cx < w / 2 else "R")
Output (o): “TR” (program execution)
<think> 1. The input class is "ship". 2. In the image, there are multiple ships docked at the harbor. 3. The task is to find the largest ship and determine the quadrant where its center of mass lies. 4. From the image, the long vessel docked at the top of the image appears to be the largest ship. 5. The center of mass calculation will be applied to this ship to determine the quadrant it falls into. Let's calculate the center of mass for the largest ship. The coordinates of the ship in the image are approximately: - Top-left corner: (260, 60) / Bottom-right corner: (540, 130) The center of mass calculation for a rectangle is at the midpoint of the top-left and bottom-right corners. The center of mass for the ship is: - X-coordinate: (260 + 540) / 2 = 400 / Y-coordinate: (60 + 130) / 2 = 95 Since the center of mass (400, 95) is above the middle of the image (h/2 = 600/2 = 300) and to the right of the middle of the image (w/2 = 600/2 = 300), the quadrant is the topright (TR). Therefore, the output is 'TR’. </think> <answer>TR</answer>
Answer (𝐨): “TR” (Correct)
Figure 5: Qualitative analysis of deduction. Given image I, argument a = "ship", and program p, the solver’s Chain-of-Thought follows the program’s control flow and predicts ô = "TR", which exactly matches the program-executed label o = p(a; I). Table 2 presents performance on GEOBench-VLM with varying numbers of active reasoning modes. Among singleton variants, Deduction-only performs the best, as it aligns with the downstream task of direct answer prediction. By contrast, among drop-one variants, removing Abduction ranks the worst, implying that reasoning backward from outputs to plausible inputs provides a learning signal that neither deduction nor induction can fully substitute. Both BaseGen and SolvOnly fall short of the full GeoX. The drop in BaseGen reveals that exposing the model to the same volume of image data is not sufficient; problem complexity must adapt as the solver progresses. The drop in SolvOnly further shows that self-play alone yields limited advantage unless the proposer is rewarded for producing problems that are challenging yet learnable. Together, these results demonstrate that GeoX draws its strength not only from self-generated supervision but also from problems that adapt to the frontier of the solver’s ability.
4
Discussion
We investigate the behavior of GeoX along three complementary axes through the following questions, with extended results provided in Appendices F, G, and H. Q. How broad is the compositional space GeoX explores? We characterize the compositional structure of problems generated by GeoX by representing each dataset as a graph over nine question dimensions (Existence, Quantity, Coverage, Comparison, Category, Relation, Scene, Direction, Overlap), shown in Figure 4. Node size reflects single-dimension frequency, and edge thickness 8
reflects pairwise co-occurrence. Existing VQA benchmarks cover only a few dimensions and leave most pairs disconnected, indicating a lack of compositionally complex geospatial reasoning problems. Our method, in contrast, exhibits a markedly denser graph in which nearly all nine dimensions are populated and most pairs are linked, highlighting that proposer-solver self-play expands both the volume of training problems and the compositional richness of their distribution. Q. What does self-play produce in practice? A qualitative deduction example illustrates the image-grounded reasoning that self-play induces in GeoX. In Figure 5, the generated problem asks in which quadrant the centroid of the largest ship lies, and the associated executable program p computes the answer by segmenting all ship objects, selecting the largest by mask area, estimating its center of mass, and mapping the resulting coordinates to one of the four quadrants {TL, TR, BL, BR}. On the right-hand side, given the image, argument a = "ship", and program p, the solver follows the program’s control flow step by step: it grounds the segment call in the visible harbor regions, identifies the dominant ship object, estimates its center of mass coordinates, compares them against the image midpoints, and predicts ô = "TR", which exactly matches the program-executed label o = p(a; I). We observe that self-play encourages the policy to use the executable program as a procedural scaffold grounded in image evidence, rather than treating it as an opaque label generator. Usage frequency in programs
Q. Which primitives are used by the proposer during self-play? Across roughly 6,500 programs constructed by the proposer over training, the usage frequency of each primitive in library F reveals which operations are called during self-play, as shown in Figure 6. Aggregation primitives are the most heavily used, with exists invoked in over 3,000 and extreme Primitive operator in over 1,800 programs, followed by count, argmin/argmax, and union. Figure 6: Usage frequency of primitives in GeoX. Each bar Geometric primitives form a second denotes the number of constructed programs that invoke a anchor, led by centroid in over 3,500 given operator in F (log scale), grouped by primitive type. programs, with area close behind in over 1,600 programs. Topological primitives surface across a wide range of programs, quadrant for localizing objects within image sub-regions and nearest for capturing inter-object proximity being the most common. Much of this distribution, spanning three groups down to a long tail of rarely used primitives, reflects GeoX’s capacity to discover problem types far beyond its hand-written seed.
5
Concluding remarks
We presented a self-play framework for geospatial reasoning that learns without human-curated data. Through a verifiable proposer-solver loop, our approach moves beyond simple pattern matching toward a fundamental understanding of the “spatial physics” encoded in overhead imagery. The results demonstrate that geospatial representations advance most effectively when learning signals align with the geometric and topological constraints of the physical world. Rather than fitting labels end-to-end, our framework grounds reasoning in executable programs whose verifiable execution exposes the spatial structure of a scene. This shift points toward a geospatial world model that treats the Earth as an environment for reasoning rather than a target for labeling. As satellite and aerial imagery scales at astronomical rates, the applications for structured reasoning will expand, equipping us with the necessary tools to plan, monitor, and protect our evolving global landscape. Limitations and future directions. This work has several limitations that suggest promising directions for future research. First, the current tool registry T contains only an open-vocabulary segmenter. While this choice helps isolate the effect of proposer-solver self-play, it restricts the present study to spatial reasoning tasks that can be verified from segmentation masks. As a result, vertical reasoning (e.g., depth and slope estimation), graph-based reasoning over road networks (e.g., connectivity and reachability), and metadata-grounded reasoning using external geospatial information (e.g., OSM tags or land-use attributes) remain outside the current scope. Future work 9
could expand the tool registry T with additional geospatial tools while preserving the self-play framework without human-curated training data. Second, the verifiable reward depends on the quality of the tools used for execution. For example, segmentation errors, especially on rare target categories, propagate as label noise through the proposer-solver loop and hinder self-improvement. Future work could enhance reward reliability with stronger verifiers, such as cross-tool agreement or self-consistency checks, thereby reducing dependence on any single perceptual module.
References [1] Donghyun Ahn, Minhyuk Song, Seungeon Lee, Yubin Choi, Jihee Kim, Sangyoon Park, Hyunjoo Yang, and Meeyoung Cha. Fine-grained socioeconomic prediction from satellite images with distributional adjustment. In Proceedings of the 32nd ACM International Conference on Information and Knowledge Management, pages 3717–3721, 2023. [2] Kyeongjin Ahn, Sungwon Han, Seungeon Lee, Donghyun Ahn, Hyoshin Kim, Jungwon Kim, Jihee Kim, Sangyoon Park, and Meeyoung Cha. Georeg: Weight-constrained few-shot regression for socio-economic estimation using llm. arXiv preprint arXiv:2507.13323, 2025. [3] Kyeongjin Ahn, Sungwon Han, Sungwon Park, Jihee Kim, Sangyoon Park, and Meeyoung Cha. Generalizable disaster damage assessment via change detection with vision foundation model. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 39, pages 27784–27792, 2025. [4] Kyeongjin Ahn, YongHun Suh, Sungwon Han, Jeasurk Yang, Hannes TaubenbÃk, ck, and Meeyoung Cha. Mapping reduced accessibility to wash facilities in rohingya refugee camps with sub-meter imagery. arXiv preprint arXiv:2511.07231, 2025. [5] Kanzhi Cheng, Li YanTao, Fangzhi Xu, Jianbing Zhang, Hao Zhou, and Yang Liu. Visionlanguage models can self-improve reasoning via reflection. In Proceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), pages 8876–8892, 2025. [6] Muhammad Sohail Danish, Muhammad Akhtar Munir, Syed Roshaan Ali Shah, Kartik Kuckreja, Fahad Shahbaz Khan, Paolo Fraccaro, Alexandre Lacoste, and Salman Khan. GEOBench-VLM: Benchmarking vision-language models for geospatial tasks. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 7132–7142, 2025. [7] Yihe Deng, Pan Lu, Fan Yin, Ziniu Hu, Sheng Shen, Quanquan Gu, James Zou, Kai-Wei Chang, and Wei Wang. Enhancing large vision language models with self-training on image comprehension. Advances in Neural Information Processing Systems, 37:131369–131397, 2024. [8] Max J. Egenhofer and Robert D. Franzosa. Point-set topological spatial relations. International Journal of Geographical Information Systems, 5(2):161–174, 1991. [9] Ritwik Gupta, Bryce Goodman, Nirav Patel, Ricky Hosfelt, Sandra Sajeev, Eric Heim, Jigar Doshi, Keane Lucas, Howie Choset, and Matthew Gaston. Creating xbd: A dataset for assessing building damage from satellite imagery. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition workshops, pages 10–17, 2019. [10] Yuan Hu, Jianlong Yuan, Congcong Wen, Xiaonan Lu, Yu Liu, and Xiang Li. Rsgpt: A remote sensing vision language model and benchmark. ISPRS Journal of Photogrammetry and Remote Sensing, 224:272–286, 2025. [11] Kartik Kuckreja, Muhammad Sohail Danish, Muzammal Naseer, Abhijit Das, Salman Khan, and Fahad Shahbaz Khan. Geochat: Grounded large vision-language model for remote sensing. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 27831–27840, 2024. [12] Sumin Lee, Sungwon Park, Jeasurk Yang, Jihee Kim, and Meeyoung Cha. Generalizable slum detection from satellite imagery with mixture-of-experts. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 40, pages 38826–38834, 2026. 10
[13] Kaiyu Li, Shengqi Zhang, Yujie Wang, Yupeng Deng, Zhi Wang, Deyu Meng, and Xiangyong Cao. Segearth-ov3: Exploring sam 3 for open-vocabulary semantic segmentation in remote sensing images. arXiv preprint arXiv:2512.08730, 2025. [14] Haotian Liu, Chunyuan Li, Yuheng Li, and Yong Jae Lee. Improved baselines with visual instruction tuning. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 26296–26306, 2024. [15] Jiaqi Liu, Lang Sun, Ronghao Fu, and Bo Yang. Towards faithful reasoning in remote sensing: A perceptually-grounded geospatial chain-of-thought for vision-language models. In The Fourteenth International Conference on Learning Representations (ICLR), 2026. URL https: //openreview.net/forum?id=lJ7zecny2e. [16] Sylvain Lobry, Diego Marcos, Jesse Murray, and Devis Tuia. RSVQA: Visual question answering for remote sensing data. IEEE Transactions on Geoscience and Remote Sensing, 58(12): 8555–8566, 2020. doi: 10.1109/TGRS.2020.2988782. [17] Yang Long, Yiping Gong, Zhifeng Xiao, and Qing Liu. Accurate object localization in remote sensing images based on convolutional neural networks. IEEE Transactions on Geoscience and Remote Sensing, 55(5):2486–2498, 2017. [18] Dilxat Muhtar, Zhenshi Li, Feng Gu, Xueliang Zhang, and Pengfeng Xiao. Lhrs-bot: Empowering remote sensing with vgi-enhanced large multimodal language model. In European Conference on Computer Vision, pages 440–457. Springer, 2024. [19] Chao Pang, Xingxing Weng, Jiang Wu, Jiayu Li, Yi Liu, Jiaxing Sun, Weijia Li, Shuai Wang, Litong Feng, Gui-Song Xia, et al. Vhm: Versatile and honest vision language model for remote sensing image analysis. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 39, pages 6381–6388, 2025. [20] Qian Shi, Da He, Zhengyu Liu, Xiaoping Liu, and Jingqian Xue. Globe230k: A benchmark dense-pixel annotation dataset for global land cover mapping. Journal of Remote Sensing, 3: 0078, 2023. [21] Minhyuk Song, Sungwon Han, Seungeon Lee, Donghyun Ahn, Jihee Kim, and Meeyoung Cha. Measuring fine-grained urban air temperature with satellite imagery. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 39, pages 28397–28404, 2025. [22] Sagar Soni, Akshay Dudhane, Hiyam Debary, Mustansar Fiaz, Muhammad Akhtar Munir, Muhammad Sohail Danish, Paolo Fraccaro, Campbell D Watson, Levente J Klein, Fahad Shahbaz Khan, et al. Earthdial: Turning multi-sensory earth observations to interactive dialogues. In Proceedings of the Computer Vision and Pattern Recognition Conference, pages 14303–14313, 2025. [23] Di Wang, Jing Zhang, Bo Du, Minqiang Xu, Lin Liu, Dacheng Tao, and Liangpei Zhang. Samrs: Scaling-up remote sensing segmentation dataset with segment anything model. Advances in Neural Information Processing Systems, 36:8815–8827, 2023. [24] Junjue Wang, Zhuo Zheng, Ailong Ma, Xiaoyan Lu, and Yanfei Zhong. Loveda: A remote sensing land-cover dataset for domain adaptive semantic segmentation. In J. Vanschoren and S. Yeung, editors, Proceedings of the Neural Information Processing Systems Track on Datasets and Benchmarks, volume 1. Curran Associates, Inc., 2021. URL https://datasets-benchmarks-proceedings.neurips.cc/paper_files/ paper/2021/file/4e732ced3463d06de0ca9a15b6153677-Paper-round2.pdf. [25] Junjue Wang, Zhuo Zheng, Zihang Chen, Ailong Ma, and Yanfei Zhong. EarthVQA: Towards queryable earth via relational reasoning-based remote sensing visual question answering. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pages 5481–5489, 2024. doi: 10.1609/aaai.v38i6.28357. [26] Chenfei Wu, Jiahao Li, Jingren Zhou, Junyang Lin, Kaiyuan Gao, Kun Yan, Sheng-ming Yin, Shuai Bai, Xiao Xu, Yilei Chen, et al. Qwen-image technical report. arXiv preprint arXiv:2508.02324, 2025. 11
[27] Jeasurk Yang, Donghyun Ahn, Junbeom Bahk, Sungwon Park, Nurrokhmah Rizqihandari, and Meeyoung Cha. Assessing climate risks from satellite imagery with machine learning: A case study of flood risks in jakarta. Climate Risk Management, 46:100651, 2024. [28] Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah D Goodman. Star: Self-taught reasoner bootstrapping reasoning with reasoning. In Proc. the 36th International Conference on Neural Information Processing Systems, volume 1126, pages 0–55, 2024. [29] Wei Zhang, Miaoxin Cai, Tong Zhang, Yin Zhuang, and Xuerui Mao. Earthgpt: A universal multimodal large language model for multisensor image comprehension in remote sensing domain. IEEE Transactions on Geoscience and Remote Sensing, 62:1–20, 2024. [30] Yuanlin Zhang, Yuan Yuan, Yachuang Feng, and Xiaoqiang Lu. Hierarchical and robust convolutional neural network for very high-resolution remote sensing object detection. IEEE Transactions on Geoscience and Remote Sensing, 57(8):5535–5548, 2019. [31] Andrew Zhao, Yiran Wu, Yang Yue, Tong Wu, Quentin Xu, Yang Yue, Matthieu Lin, Shenzhi Wang, Qingyun Wu, Zilong Zheng, and Gao Huang. Absolute zero: Reinforced self-play reasoning with zero data. In Advances in Neural Information Processing Systems (NeurIPS), 2025.
12
A
Related Work
A.1
Vision-Language Models for remote sensing
Recent progress has extended vision-language models (VLMs) to satellite and aerial imagery. RSVQA [16] framed visual question answering (VQA) as a core task for overhead imagery. RSGPT [10] and LHRS-Bot [18] then released larger multimodal datasets alongside companion benchmarks, each training its own VLM on the proposed data. EarthGPT [29] and EarthDial [22] further extend coverage to multi-sensory [29] and multi-temporal [22] imagery. A parallel line of work targets structural understanding of overhead scenes. EarthVQA [25] contributes a dataset for relational reasoning, and GEOBench-VLM [6] compiles a broad task suite for evaluating specialized geospatial capabilities. Despite their growing scale and scope, these datasets all depend on manual annotation. Subsequent VLMs go beyond scaling data toward refining the supervision itself. GeoChat [11] unifies grounded conversation, VHM [19] enforces factual honesty with deceptive instructions, and RSThinker [15] elicits Chain-of-Thought rationales. However, these efforts likewise inherit human supervision, hindering scalability and risking error propagation. GeoX removes this dependence by deriving its supervision from the imagery itself. A.2
Self-improvement in Foundation Models
A growing body of work scales learning by letting a model generate and learn from its own outputs. STaR [28] introduced this idea in language domain, R3 V [5] extended it to vision-language domain, and STIC [7] redirected it to image descriptions for visual comprehension. These approaches push supervision beyond manual curation, yet the self-generated signals they rely on are difficult to verify independently, accumulating noise across iterations. Self-play with verifiable rewards allows models to use automatically checked outputs as reinforcement signals. Absolute Zero [31] is a representative example, which employs a proposer-solver framework for self-play through executable verification in code and mathematics. While these domains offer clear-cut correctness, open-ended visual tasks typically lack reliable ways to verify model-generated supervision. We close this gap for remote sensing imagery by routing perception through executable spatial programs whose outputs serve as verifiable rewards.
B
Datasets
This section describes the datasets used for training and evaluating GeoX. Table 3 summarizes imagery source, geographically covering region, spatial resolution, and size. B.1
Training dataset
For training, GeoX draws images from two remote sensing datasets, SAMRS-FAST [23] and Globe230k [20]. Because our method generates question-answer pairs through self-play, training uses only the image collections from these datasets, without relying on their annotations. SAMRS-FAST is a high-resolution dataset for fine-grained object detection across 37 categories, derived from FAIR1M-2.0 aerial imagery (0.3–0.8 m GSD) collected globally. Globe230k is a large-scale dataset for land cover semantic segmentation, derived from Google Earth imagery (1 m GSD) sampled worldwide. B.2
Evaluation dataset for VQA
We evaluate the visual question answering capability of GeoX on three remote sensing VQA benchmarks: RSVQA-HR [16], EarthVQA [25], and GEOBench-VLM [6]. RSVQA-HR uses USGS High-Resolution Orthoimagery (0.15 m GSD, captured by low-altitude flight missions) over three USA cities. Its QA pairs are template-generated from OpenStreetMap annotations and span four types: presence, comparison, counting, and area. 13
Table 3: Summary of training and evaluation datasets. Data is characterized by source, geographic coverage, resolution (ground sample distance per pixel), and size. Evaluation is zero-shot for GeoX, which is trained without any question-answer pair from the evaluation benchmarks. Sizes for the evaluation benchmarks correspond to their test splits. Imagery Source
Region
Resolution
# Images
Training SAMRS-FAST Globe230k
FAIR1M-2.0 Google Earth
Predominantly China Worldwide
0.3–0.8 m 1m
64,147 232,819
VQA Evaluation RSVQA-HR EarthVQA GEOBench-VLM
USGS HRO Google Earth Mixed
USA (3 cities) China (3 cities) Worldwide
0.15 m 0.3 m Varies
9,505 (2,226 test) 6,000 (1,809 test) 2,503
Worldwide Worldwide
0.15–1.2 m 0.3–3 m
21,761 (10,943 test) 976
Object Counting Evaluation HRRSD Google Earth, Baidu Map RSOD Google Earth, Tianditu
EarthVQA uses Google Earth imagery (0.3 m GSD) covering 18 districts in China [24]. Its QA pairs span six question types, from auto-generated basic judging and counting to manually annotated relational analysis for urban planning. GEOBench-VLM draws from a heterogeneous mixture of source datasets including DOTA, DIOR, xBD, FAIR1M, fMoW, RarePlanes, and FireRisk, across optical, bi-temporal, and SAR modalities. Its QA pairs are formatted as 5-way multiple-choice items, covering 8 broad categories and 31 fine-grained sub-tasks. We evaluate 17 sub-tasks most relevant to geospatial reasoning, categorized into object localization & counting, scene understanding, object classification, and event detection. B.3
Evaluation dataset for Object Counting
We evaluate the object counting capability of GeoX on two remote sensing object detection benchmarks: HRRSD [30] and RSOD [17]. HRRSD uses Google Earth and Baidu Map imagery (0.15–1.2 m GSD) covering diverse regions worldwide. It contains 21,761 images with 55,740 annotated instances spanning 13 object categories, including vehicles, aircraft, ships, and sports facilities. RSOD uses Google Earth and Tianditu imagery (0.3–3 m GSD) across heterogeneous terrain worldwide. It contains 976 images with 6,950 annotated instances across four object categories of aircraft, oil tank, overpass, and playground.
C
Baselines
This section provides additional details on each baseline model used in our comparison, grouped into base general-purpose VLMs and conventional geospatial VLMs fine-tuned on curated remote sensing data. C.1
Base VLMs
Qwen-2.5-VL-7B-Instruct [26] and LLaVA-1.5-7B [14] are used as base VLMs, serving both as the initialization for our self-play training and as zero-shot baselines for evaluation. Qwen-2.5-VL-7B-Instruct is a general-purpose vision-language model from the Qwen-2.5-VL family that combines the Qwen-2.5 language backbone with a Vision Transformer encoder. We evaluate it zero-shot, without any remote-sensing-specific adaptation. LLaVA-1.5-7B is a general-purpose vision-language model that connects a Vicuna-1.5 language backbone with a CLIP visual encoder, trained on visual instruction-tuning data drawn primarily from natural images. We evaluate it zero-shot, without any remote-sensing-specific adaptation. 14
C.2
Conventional Remote Sensing VLMs
We compare GeoX against four geospatial VLMs fine-tuned on curated remote sensing data: GeoChat [11], VHM [19], EarthDial [22], and RSThinker [15]. GeoChat adapts LLaVA-1.5-7B to remote sensing through LoRA fine-tuning on roughly 318K instruction-following pairs. It supports high-resolution imagery and region-level prompts. VHM fine-tunes LLaVA-1.5-7B on 1.4M image-text pairs with rich-content captions and an honest instruction dataset that pairs factual questions with deceptive ones. EarthDial extends InternVL2 to multi-sensor and multi-temporal imagery via instruction tuning on over 11.11M pairs. RSThinker trains a base VLM through a two-stage alignment strategy on a 380K-sample dataset of geospatial Chain-of-Thought rationales, producing both a final answer and a verifiable analytical trace.
D
Additional implementation details
This section provides additional implementation details on the training setup of GeoX, including model initialization, training data, execution environment, self-play configuration, optimization, and compute. Setup. We initialize GeoX from a base vision-language model, using either Qwen-2.5-7B-Instruct or LLaVA-1.5-7B depending on the experiment. Training uses images drawn from two remote sensing datasets, SAMRS-FAST [23] and Globe230k [20]. Because GeoX generates supervision through self-play, we use only the image collections from these datasets and do not rely on their annotations. The execution interface consists of a primitives library F and a tool registry T , with callable interface E = F ∪ T . The primitives library F implements deterministic geometric, topological, and aggregation operations using NumPy, SciPy, and scikit-image. The tool registry T contains a single open-vocabulary segmenter, SegEarth-OV3 [13], which returns image-grounded masks used by executable programs. Self-play configuration. We maintain three mode-specific banks, Dabd , Dded , and Dind , which provide in-context references for proposal and refill failed generations. Each bank begins with Nseed = 100 seed problems, as described in Section 2.3. At each proposal step, we use batch size B = 32 per mode. For abduction and deduction, the proposer generates one image-grounded executable problem per sampled image, conditioned on K = 6 in-context references from the corresponding bank. For induction, Nio =6 input-output pairs are prepared for each program. These pairs are split evenly into a visible subset used by the solver to synthesize the program and a heldout subset used to score it. For each newly proposed problem, the solver makes R=8 attempts whose averaged reward defines the problem’s learnability, which in turn defines the proposer reward rprop (Eq. 10). The solver itself is trained on a separately sampled batch of B problems from the corresponding bank, where each rollout’s prediction accuracy, scored by the executor, defines the solver reward rsolve (Eq. 7 and 8). SFT warm-up. Before RL through self-play, we optionally run a brief SFT stage that teaches πθ ’s output schema only: the proposer’s outputs (question q, argument a, and program p) and the solver’s <think>...</think> / <answer>...</answer> format. Correctness across the three reasoning modes, use of the call interface E = F ∪ T , and proposal learnability are all left to RL, making this stage a parser warm-up rather than a knowledge injection. The corpus is built by running the self-play loop with the policy frozen and supervision supplied by the executor. πθ proposes problems for abduction and deduction, and we retain those for which o = p(a; I) executes deterministically. For the solver, we keep πθ ’s <think> traces but replace <answer> with the executor-verified o. Induction is omitted from the warm-up to keep its data construction simple. The resulting corpus (∼1K proposer and ∼3K solver examples) LoRA-fine-tunes the base model (r=32, α=64) for 2 epochs at learning rate 5e−5. 15
Optimization and compute. We optimize the policy via reinforcement learning using Task-Relative REINFORCE++ [31]. Each pair of role and reasoning mode is treated as a separate task, yielding six tasks in total (2 roles × 3 modes). During each update, the six tasks are sampled in equal proportion. We set the weight between proposer and solver objectives to λ = 1, giving equal weight to proposer and solver rewards. We train with the AdamW optimizer, learning rate 5e−7, weight decay 0, gradient clipping threshold 1.0, and a constant learning rate schedule with no warm-up. The sampling temperature is set to 1.0 for proposal and 1.0 for solving. Unless otherwise stated, we follow the training settings of prior work [31]. A full self-play run consists of 150 steps and takes approximately 60 hours on 4 NVIDIA H200 GPUs.
16
E
Additional experimental results
starth40_step_curves.html h40_step_curves.html start
This section presents additional experimental results due to space constraints. E.1
Training dynamics during self-play
Accuracy Accuracy
Accuracy Accuracy
Accuracy Accuracy
We examine the training dynamics of GeoX through VQA benchmarks: RSVQA-HR, EarthVQA, and GEOBench-VLM. For each benchmark, we select the subtask most closely tied to geospatial reasoning among its available evaluation categories: Comparison for RSVQA-HR, Reasoning-based Counting for EarthVQA, and Spatial Relation Classification for GEOBench-VLM. Figure 7 shows the accuracy (%) of GeoX as a function of training steps. Across all three subtasks, accuracy exhibits a consistent upward trend as self-play proceeds, indicating that the proposer-solver loop progressively strengthens the model’s spatial reasoning capability. The vertical axis is scaled to the dynamic range of each task to make per-task trends visible.
Training Trainingsteps steps Training steps
Training steps Training steps Training steps
(a) RSVQA-HR (Comparison)
Training steps Training steps Training steps
(b) EarthVQA (Reasoning-based (c) GEOBench-VLM (Spatial RelaCounting) tion Classification)
Figure 7: Training dynamics during self-play. Task accuracy of GeoX over training steps on representative geospatial reasoning subtasks drawn from three remote sensing VQA benchmarks: Comparison (RSVQA-HR), Reasoning-based Counting (EarthVQA), and Spatial Relation Classification (GEOBench-VLM). E.2
Evaluation on Object Counting
Beyond the VQA results in Section 3.2, we further evaluate GeoX on object counting. Datasets, baselines details follow Section 3.1, Appendix B, and Appendix C. Table 4 reports the performance of GeoX against strong zero-shot and conventional remote sensing VLMs. Note that RSThinker’s entries on HRRSD are marked with †, as HRRSD overlaps with its training distribution and is therefore excluded from the bold comparison. Both GeoXL and GeoXQ improve over their respective base models in average accuracy. Table 4: Results on Object Counting benchmarks. Performance of GeoX, instantiated from two base VLMs (LLaVA and Qwen), is compared against six baselines on HRRSD and RSOD. Baseline models fine-tuned on fully human-curated data are grey shaded. The best result in each row is shown in bold, and our results are highlighted in blue when they surpass the corresponding base (LLaVA or Qwen). † HRRSD lies in RSThinker’s training distribution, so its numbers (and any average that includes HRRSD) are not directly comparable to the zero-shot evaluations of the other rows and are excluded from bold consideration. Base Dataset
Metric
LLaVA
Conventional Qwen
GeoChat
VHM
EarthDial
Self-play GeoXL
GeoXQ
†
RSThinker
HRRSD
Acc ↑ MAE ↓
55.6 1.03
60.5 0.73
52.4 1.50
62.5 0.79
59.6 0.87
85.5 0.20†
55.0 1.00
63.1 0.72
RSOD
Acc ↑ MAE ↓
33.3 4.49
27.8 3.31
16.0 8.17
27.1 8.47
10.4 8.83
37.3 6.19
37.5 4.32
30.6 3.69
Average
Acc ↑ MAE ↓
44.5 2.76
44.2 2.02
34.2 4.84
44.8 4.63
35.0 4.85
61.4† 3.20†
46.3 2.66
46.8 2.21
17
F
Compositional space analysis
This section supplements the details behind the compositionality analysis presented in Section 4 (Figure 4). We describe (i) the definition of nine question dimensions used to characterize each problem, (ii) the deterministic mapping rules that assign dimensions from two distinct problem representations (natural-language questions in existing VQA benchmarks and executable Python programs constructed by GeoX during self-play), and (iii) representative examples illustrating the rules. F.1
Nine question dimensions
We adopt a nine dimensions of atomic geospatial concept to make problems from heterogeneous representations comparable. The dimensions are designed to satisfy two desiderata: 1. Primitive coverage. Every primitive in the call interface F (Section 2.3) is assigned to exactly one dimension, ensuring that any program constructed by the proposer is representable in the nine dimensions. 2. Benchmark coverage. Every question in our evaluation benchmarks (RSVQA-HR, EarthVQA, GEOBench-VLM) is assigned to at least one dimension, ensuring a fair side-by-side comparison. Each problem is mapped to a set of dimensions rather than a single one, since real spatial questions routinely combine multiple atomic geospatial concepts. For instance, “which class occupies the largest area?” invokes both C OVERAGE (pixel area) and C OMPARISON (extremum selection). Table 5 summarizes the nine dimensions together with their definitions and matching rule for the two problem representations. Table 5: Nine question dimensions for compositional analysis. Each problem is mapped to a set of dimensions via deterministic rules. The question rule applies to natural-language questions in existing VQA benchmarks (RSVQA-HR, EarthVQA, GEOBench-VLM); the code rule applies to executable programs constructed by GeoX. Dimension
Definition
Question rule
Code rule
E XISTENCE Q UANTITY C OVERAGE C OMPARISON
Presence of an entity Cardinality of a class Pixel area of a region Extremum selection or ordering Reference to an object class Continuous spatial proximity Reference to a scene-type class Cardinal or quadrant assignment Set-theoretic mask interaction
are there, is there, any how many, number of area of, ratio of, how large larger/smaller, most/least, X or Y what type of object/aircraft
np.any, .any(), is not None len( ), np.count_nonzero np.sum, .sum(), identifier area max, min, argmax, argmin
C ATEGORY R ELATION S CENE D IRECTION OVERLAP
F.2
near, next to, between, adjacent land use, rural/urban, what kind of scene north/south/east/west, top of, where is both, intersection, overlap
String literal of an object class (e.g., "vehicle") center_of_mass, distance_transform, cdist String literal of a scene class (e.g., "water") String literal in {north, TL, NW, . . . } np.logical_and, m & m, m | m
Deterministic mapping rules
For each problem p, we compute its dimension set C(p) ⊆ {E XISTENCE, . . . , OVERLAP} via a representation-specific procedure. Here, problem includes both natural-language questions presented by benchmarks and the executable Python program generated through self-play of GeoX. Natural-language questions (VQA benchmarks). For a question q in RSVQA-HR, EarthVQA, or GEOBench-VLM, we apply regular expressions to the lower-cased text and assign every matched dimension to C(q). Two overriding rules resolve common ambiguities found in practice: 18
• Comparison overrides Existence. Questions such as “Are there more vehicles than ships?” contain the trigger are there but are genuinely comparative. We therefore drop E XISTENCE whenever C OMPARISON is also matched. • Scene overrides Existence. Questions such as “Is this a rural or urban scene?” perform scene-type classification rather than presence detection. We drop E XISTENCE whenever S CENE is matched and no explicit existence trigger (are there, is there, any) is present. Executable programs (GeoX). below:
For a program p produced by the proposer, we follow the procedure
1. For each operational dimension d ∈ {E XISTENCE, Q UANTITY, C OVERAGE, C OMPARISON, R ELATION, OVERLAP}, add d to C(p) if any associated regular expression matches a substring of s. 2. Add C ATEGORY if p contains a string literal naming one of the 19 object classes (e.g. vehicle, ship, building, tree). 3. Add S CENE if p contains a string literal naming one of the 11 scene classes (road, water, parking_lot, vegetation, forest, grass, cropland, land, bareland, intersection, roundabout) or the identifier scene_classes. 4. Add D IRECTION if p contains a string literal drawn from the set of 18 direction tokens (cardinal directions and quadrant abbreviations). Verification. We verified the procedure by manually annotating a held-out sample of 100 problems (25 from each of RSVQA-HR, EarthVQA, GEOBench-VLM, and GeoX) and observed that every problem agreed on dimension membership.
19
F.3
Illustrative Examples
Figure 8 and Figure 9 illustrate the mapping rules across both problem representations. Q: "Are there more buildings than roads in this image?" # ’more ... than’ -> Comparison # ’are there’ overridden by Comparison rule (a) Example of C OMPARISON + Q UANTITY problem in RSVQA-HR dataset Q: "What kind of scene is shown?" # ’what kind of scene’ -> Scene (b) Example of S CENE problem in EarthVQA dataset Q: "How many cargo ships are visible in the image?" # ’how many’ -> Quantity # ’cargo ship’ (object class) -> Category (c) Example of Q UANTITY + C ATEGORY problem in GEOBench-VLM dataset
Figure 8: Examples of rule-based mapping of natural language problems.
def f(image, a): x1, x2 = a # x = ("water", "vegetation") return x1 if np.sum(segment(image, x1)) > np.sum(segment(image, x2)) else x2 # np.sum(.) -> Coverage # > with selection -> Comparison # "water", ... -> Scene (a) Example of C OVERAGE + C OMPARISON + S CENE problem generated in GeoX self-play def f(image, a): x1, x2 = a # ("vehicle", "road") m2 = segment(image, x2) dt = distance_transform_edt(~m2) m1 = segment(image, x1) i = int(np.argmin([dt[ndi.center_of_mass(m)] for m in m1])) cy, cx = ndi.center_of_mass(m1[i]) return ("TL" if cx < W/2 and cy < H/2 else "TR" if cy < H/2 else "BL" if cx < W/2 else "BR") # "vehicle" -> Category # distance_transform_edt, center_of_mass -> Relation # "TL", "TR", ... -> Direction (b) Example of C ATEGORY + R ELATION + D IRECTION problem generated in GeoX self-play
Figure 9: Examples of rule-based mapping of problems generated in GeoX self-play.
20
G
Qualitative analysis of the three reasoning modes
This section supplements the qualitative analysis presented in Section 4 (Figure 5). We extend the single deduction example to all three reasoning modes, with one representative example per mode drawn from a distinct image and program. For each mode, we present the visible elements of the triplet (p, a, o), the solver’s Chain-of-Thought, and its prediction verified against the program-executed output. In abduction (Figure 10), given (I, p, o), the solver simulates p forward and searches for an argument â whose execution reproduces o. In deduction (Figure 11), given (I, p, a), the solver follows the control flow of p and predicts ô; this example is reproduced from the main paper for direct comparison. In induction (Figure 12), given input-output pairs {(at , ot )}t∈V , the solver synthesizes p̂ consistent with the visible pairs. Across all modes, the solver’s reasoning is anchored in concrete image regions rather than treating p as an opaque label generator, indicating that self-play encourages the program to act as a procedural scaffold grounded in image evidence. Query (q): “ Which class has more instances, tennis-court or baseball-field in the image? Return 'tie' if equal. ”
Image (I)
Segmentation
Argument (a): (“tennis-court”, “football-field”) Program (p): def f(image, a): from tools import segment c1, c2 = a l1 = segment(image, c1) l2 = segment(image, c2) l1 = l1 if isinstance(l1, list) else [] l2 = l2 if isinstance(l2, list) else [] if len(l1) > len(l2): return c1 if len(l2) > len(l1): return c2 return "tie"
Output (o): “tie” (program execution)
<think> The image shows several distinct objects: a football field (the large green field with markings) is visible in the top-right area of the image, a tennis court is visible in the top-left corner, a parking lot with many vehicles is present on the left side, a long building with a light-colored roof is in the middle-left area, a road runs horizontally across the lower portion of the image, and trees are scattered throughout the image. The function f compares the lengths of the lists returned by segment(image, c1) and segment(image, c2) and returns the class name with more instances, or "tie" if the lengths are equal. We need to count the instances of football-field and tennis-court. Let's count the instances of each class: segment(image, "football-field") appears to return 1 instance (the football field in the top-right area), and segment(image, "tennis-court") appears to return 1 instance (the tennis court in the top-left corner). The function f will compare the two lengths: len(segment(image, "football-field")) = 1 and len(segment(image, "tennis-court")) = 1. Since both classes have the same number of instances, the function will return "tie". </think> <answer>(“tennis-court”, “football-field”)</answer>
Answer (𝐚): (“tennis-court”, “football-field”) (Correct)
Figure 10: Qualitative analysis of abduction. Given (I, p, o), the solver infers â by simulating p forward and searching for arguments whose execution reproduces the observed output o.
21
Query (q): “ In which quadrant (TL, TR, BL, BR) does the centroid of the largest ship lie in the image? ”
Image (I)
Segmentation
Argument (a): “ship”
<think> 1. The input class is "ship". 2. In the image, there are multiple ships docked at the harbor. 3. The task is to find the largest ship and determine the quadrant where its center of mass lies. 4. From the image, the long vessel docked at the top of the image appears to be the largest ship. 5. The center of mass calculation will be applied to this ship to determine the quadrant it falls into. Let's calculate the center of mass for the largest ship. The coordinates of the ship in the image are approximately: - Top-left corner: (260, 60) / Bottom-right corner: (540, 130)
Program (p): def f(image, a): import numpy as np from scipy.ndimage import center_of_mass from tools import segment instances = segment(image, a) if not isinstance(instances, list) or not instances: return "none" largest = max(instances, key=lambda m: int(np.sum(m))) cy, cx = center_of_mass(largest) h, w = largest.shape return ("T" if cy < h / 2 else "B") + ("L" if cx < w / 2 else "R")
Output (o): “TR” (program execution)
The center of mass calculation for a rectangle is at the midpoint of the top-left and bottom-right corners. The center of mass for the ship is: - X-coordinate: (260 + 540) / 2 = 400 / Y-coordinate: (60 + 130) / 2 = 95 Since the center of mass (400, 95) is above the middle of the image (h/2 = 600/2 = 300) and to the right of the middle of the image (w/2 = 600/2 = 300), the quadrant is the topright (TR). Therefore, the output is 'TR’. </think> <answer>TR</answer>
Answer (𝐨): “TR” (Correct)
Figure 11: Qualitative analysis of deduction (reproduced from Figure 5). Given (I, p, a), the solver follows the control flow of p and predicts ô, which exactly matches the program-executed label o = p(a; I).
Query (q): “ How many instances of the given object class are in the image? ” <think> The task is to deduce the function that computes the number of instances of a given class from the masks provided by the system. Let's analyze the given input/output pairs and the satellite image:
Image (I)
Segmentation
Argument (a): “vehicle”, “bridge”, “football-field” Program (p):
1. **Input 0**: `vehicle` - **Output 0**: `3` - From the image, we can see three vehicles on the road. 2. **Input 1**: `bridge` - **Output 1**: `2` - From the image, we can see two bridges spanning over the water. 3. **Input 2**: `football-field` - **Output 2**: `1` - From the image, we can see one football field in the top-right corner.
def f(image, a): from tools import segment instances = segment(image, a) if not isinstance(instances, list): return 0 return len(instances)
Based on these observations, the function needs to count the number of instances of the given class. The class names are `vehicle`, `bridge`, and `football-field`, and the outputs are the counts of instances for each class. The function should return the length of the list of instance masks for the given class. </think> <answer> def f(image, a): from tools import segment return len(segment(image, a)) </answer>
Output (o): 3, 2, 1 (program execution)
Answer (𝐩): def f(image, a): return len(segment(image, a)) (Correct)
Figure 12: Qualitative analysis of induction. Given input-output pairs {(at , ot )}t∈V , the solver synthesizes a program p̂ consistent with the visible pairs.
22
H
Primitives library and usage in self-play
This section supplements the analysis presented in Section 4 (Figure 6). We describe (i) the primitive library F exposed by the call interface, (ii) the procedure for detecting primitive invocations in programs, and (iii) the resulting per-primitive usage statistics. H.1
Primitive library
The call interface F exposes 22 primitives organized into three groups. The first two groups follow the standard geometric-topological distinction in spatial information systems [8]; we extend it with a third group for operations over sets of masks. Geometric primitives extract metric attributes from a single mask, such as area, bounding box, centroid, or principal orientation. Topological primitives capture spatial relations between two masks (adjacency, containment, distance, overlap, proximity, relative direction), or between a mask and image partitions such as grids and quadrants. Aggregation primitives reduce or transform over a set of masks, producing outputs such as a count, an extremum, a filtered subset, a presence check, or a union. Table 6 lists the primitives in each group. Table 6: Primitive library F. Within each group, primitives are listed alphabetically.
H.2
Group
Primitives
Geometric
area, bbox, centroid, orientation
Topological
adjacent, contains, distance, grid, in_cell, nearest, overlaps, quadrant, relpos
Aggregation
argmin/argmax, components, count, exists, extreme, filter_by, largest/smallest, mean_position, union
Deterministic detection rules
For each program p constructed by the proposer, we determine its set of primitives A(p) ⊆ F via anchored regular-expression matching on the source code. A primitive is added to A(p) if any of its associated patterns matches a substring of p. Patterns are designed to identify the operations a program performs, regardless of surface syntax, covering both explicit calls to a primitive (e.g., centroid(m)) and the standard library idioms that realize the same operation inline (e.g., ndi.center_of_mass(m)). Pattern construction. We derived these patterns in two stages. First, for each primitive, we enumerated the standard library functions and idioms that implement it (e.g., np.any for exists, scipy.ndimage.center_of_mass for centroid). Second, we inspected a sample of programs and added patterns for any recurring idioms not covered by the initial set. The full set of patterns and their match counts are reported alongside each primitive in Table 7. Verification. We verified the matching procedure by manually annotating a held-out sample of 100 programs and comparing the predicted primitive set A(p) against expert labels, observing every problem agreed on primitive membership. H.3
Usage statistics
Across the 6,558 programs, Table 7 shows the program count, percentage, and top detection patterns for each primitive. Every group contains primitives appearing in over 1,000 programs, with centroid (55.4%), exists (48.7%), quadrant (32.9%), extreme (28.8%), count (25.7%), and area (25.0%) dominating the distribution.
23
Table 7: Per-primitive usage across 6,558 programs. A program is counted once per primitive. Pattern hits in parentheses give the number of programs matched by each pattern; a program may match multiple patterns of the same primitive. Within each group, primitives are ordered by frequency. Group
Primitive
Count
%
Geometric
centroid area bbox orientation
3,630 1,642 282 3
55.4 25.0 4.3 0.0
center_of_mass (3,558), cx, cy (2,331) np.sum (1,604), identifier area (41) np.where (255), xs/ys.min/max (136) regionprops (3)
quadrant nearest
2,157 741
32.9 11.3
distance grid relpos overlaps adjacent contains in_cell
272 75 70 52 3 1 0
4.1 1.1 1.1 0.8 0.0 0.0 0.0
cy < H/2 (2,002), cx < W/2 (1,838) distance_transform_edt (713), min_dist, nearest (382) Euclidean expansion (249), np.linalg.norm (2) H/N, W/N for N ≥ 3 (68) cardinal literals ("N", "NE", . . . ) (70) np.any( & ) (39), combined & (23) adjacent (3) contains (1) —
3,194 1,887 1,686 1,129 985 253 152 11 1
48.7 28.8 25.7 17.2 15.0 3.9 2.3 0.2 0.0
np.any (3,189), .any() (9) quadrant literals (1,050), direction literals (841) len(masks[. . . ]) (1,168), len(instances) (518) argmax (1,079), argmin (70) |= (977), combined = (960) max(. . . , key=) (220), sorted (29) avg_y (115), avg_x (113) list comprehension with if (11) from scipy.ndimage import label (1)
Topological
Aggregation
exists extreme count argmin/argmax union largest/smallest mean_position filter_by components
24
Top detection patterns
I
Full results
This section reports the experimental results in Section 3. We provide (i) per-subtask breakdowns of the main VQA results in Table 1 (Section I.1), (ii) per-subtask breakdowns of the ablation study in Table 2 (Section I.2). I.1
Full sub-task results on VQA benchmarks
Table 1 in the main paper presents the performance of GeoX and other baselines on RSVQA-HR and EarthVQA at the per-subtask level, and on GEOBench-VLM at the category level by averaging the subtasks within each category. Here, we provide the per-subtask breakdown for all benchmark datasets, including GEOBench-VLM across all 17 spatial-understanding tasks. Table 8: Full results on VQA benchmarks. Performance of GeoX, instantiated from two base VLMs (LLaVA and Qwen), is compared against six baselines on RSVQA-HR, EarthVQA, and GEOBench-VLM. For each model, the number of human-curated QA pairs used for fine-tuning is listed; baseline models fine-tuned on fully curated data are grey shaded. The best result in each row is shown in bold, and our results are highlighted in blue when they surpass the corresponding base (LLaVA or Qwen). Base Benchmark / Task
Conventional
Self-play
LLaVA
Qwen
GeoChat
VHM
EarthDial
RSThinker
GeoXL
GeoXQ
0
0
318K
1.4M
11.1M
380K
0
0
Presence Count Area Comparison
57.9 30.3 2.7 52.5
60.1 35.2 10.3 69.7
57.9 25.5 41.6 74.8
72.3 13.5 13.5 70.7
60.0 25.9 38.8 78.9
55.4 22.1 22.1 68.7
61.9 30.5 40.3 57.5
63.2 36.6 16.5 72.0
Average
35.9
43.8
50.0
42.5
50.9
42.1
47.6
47.1
Basic Judging Reasoning-based Judging Reasoning-based Counting Basic Counting Object Situation Analysis Comprehensive Analysis
78.6 55.8 24.8 60.6 28.2 19.6
78.0 73.0 23.4 62.4 29.4 33.6
66.6 37.0 16.6 26.0 2.2 7.8
79.0 71.8 12.8 39.6 23.2 24.6
76.2 41.4 5.6 53.0 4.0 11.0
69.4 42.6 15.4 45.8 25.2 19.0
82.2 53.8 33.8 70.2 30.4 19.5
78.2 68.6† 26.6 69.4 30.2 34.4
Average
44.6
50.0
26.0
41.8
31.9
36.2
48.3
51.2
Spatial Relation Classification Building Counting General Vehicle Counting Specific Vehicle Counting General Aircraft Counting Specific Aircraft Counting Marine Debris Counting Trees Counting Tree Health Assessment Water Bodies Counting Scene Classification Land Use Classification Crop Type Classification Aircraft Type Classification Ship Type Classification Disaster Type Classification Fire Risk Assessment
35.2 17.6 12.7 17.0 18.0 22.1 17.0 15.3 17.8 32.9 67.7 46.6 25.5 40.0 30.4 11.8 17.5
68.2 29.4 38.7 29.0 32.0 22.9 35.0 29.4 24.8 63.5 79.5 53.9 30.9 48.0 39.6 70.6 20.0
53.4 17.6 16.0 17.4 22.0 16.4 18.0 21.2 19.1 21.2 79.5 51.0 18.2 36.0 32.9 58.8 16.7
57.1 19.4 16.7 21.0 14.0 20.7 29.0 24.7 19.1 48.2 83.6 60.0 21.8 48.0 24.6 64.7 29.2
48.9 21.2 16.0 23.2 21.0 22.9 26.0 21.2 16.6 30.6 94.0 62.0 25.5 36.0 35.7 17.6 15.8
62.9 12.9 28.0 12.9 29.0 21.4 37.0 5.9 8.9 28.2 88.4 49.5 10.9 45.0 27.5 23.5 18.3
36.3 21.2 13.3 19.2 22.0 20.7 16.0 20.0 15.9 37.7 68.0 46.1 27.3 42.0 30.9 11.8 16.7
70.0 37.1 38.7 33.9 33.0 27.9 38.0 28.2 19.1 69.4 79.3 55.1 27.3 53.0 42.0 64.7 20.0
Average
26.2
42.1
30.3
35.4
31.4
30.0
27.4
43.3
# Curated RSVQA-HR
EarthVQA
GEOBench-VLM
25
I.2
Full sub-task results on the ablation study
Table 2 in the main paper summarizes the ablation across the four task categories of GEOBench-VLM. Here, we provide the per-subtask breakdown for each variant of GeoX. Singleton variants keep one solver mode active (A: Abduction, D: Deduction, I: Induction); Drop-one variants disable one of the three; Training variants (BaseGen and SolvOnly) retain all three modes but modify problem generation or proposer reward as described in Section 3.3; Full denotes the default configuration. Table 9: Full ablation study results on GEOBench-VLM. Columns specify which solver modes are active: A (Abduction), D (Deduction), I (Induction). Singleton Variants keeps one mode; Drop-one Variants removes one; Training Variants use all three reasoning modes. Full denotes our default configuration. The best result in each row is shown in bold and the second-best is shown in underline. Singleton Variants
Drop-one Variants
Training Variants
Full
Config. Active Modes
Abd A
Ded D
Ind I
−Abd D,I
−Ded A,I
−Ind D,A
BaseGen D,A,I
SolvOnly D,A,I
GeoX D,A,I
Object Localization & Counting Spatial Relation Classification Building Counting General Vehicle Counting Specific Vehicle Counting General Aircraft Counting Specific Aircraft Counting Marine Debris Counting Trees Counting Tree Health Assessment Water Bodies Counting
67.8 33.5 34.7 27.7 29.0 22.9 33.0 22.4 21.7 62.4
67.8 35.3 36.7 28.6 33.0 25.0 35.0 25.9 19.1 65.9
67.8 32.9 36.0 27.7 28.0 28.6 34.0 24.7 19.7 64.7
67.8 32.9 34.7 26.3 28.0 22.1 39.0 29.4 19.7 64.7
67.8 35.3 33.3 30.8 30.0 25.7 33.0 24.7 19.1 64.7
68.5 35.9 36.7 30.4 31.0 24.3 35.0 24.7 17.8 70.6
66.5 36.5 38.0 31.7 30.0 21.4 32.0 27.1 24.8 65.9
68.2 32.9 28.7 27.7 29.0 22.1 36.0 23.5 14.6 60.0
70.0 37.1 38.7 33.9 33.0 27.9 38.0 28.2 19.1 69.4
Average
35.5
37.2
36.4
36.5
36.4
37.5
37.4
34.3
39.5
Scene Understanding Scene Classification Land Use Classification Crop Type Classification
78.1 54.4 21.8
78.6 54.9 23.6
76.6 53.4 18.2
75.4 52.5 16.4
76.9 53.7 21.8
78.1 54.7 23.6
78.6 55.4 20.0
75.4 53.2 21.8
79.3 55.1 27.3
Average
51.4
52.4
49.4
48.1
50.8
52.1
51.3
50.1
53.9
Object Classification Ship Type Classification Aircraft Type Classification
40.6 50.0
40.6 53.0
41.5 51.0
38.2 49.0
43.5 55.0
38.6 50.0
46.0 39.1
39.6 51.0
42.0 53.0
Average
45.3
46.8
46.3
43.6
49.3
44.3
42.6
45.3
47.5
Event Detection Disaster Type Classification Fire Risk Assessment
58.8 19.2
64.7 20.0
58.8 21.7
58.8 21.7
64.7 22.5
64.7 20.8
70.6 23.3
70.6 22.5
64.7 20.0
Average
39.0
42.4
40.3
40.3
43.6
42.8
47.0
46.6
42.4
Total Average
39.9
41.6
40.3
39.8
41.3
41.5
41.6
39.8
43.3
26