1 Introduction↩︎

Modern mobile map applications such as Amap¹ bridge the digital and physical worlds. In Amap homepage recommendation, the system employs an agent to recommend various tool cards, including ride-hailing, destination exploration, and local lifestyle services. The agent identifies potential intents from user profiles, historical interactions, and spatiotemporal contexts, and then invokes specific tools that return POIs or content. These results are ultimately presented as a sequence of cards. Throughout this paper, an intent denotes a parameterized invocation of an Amap homepage tool (e.g., ride-hailing with origin and destination arguments), and a card denotes the resulting UI surface; the output of GPlan is therefore an ordered sequence of intents, which the production stack renders as cards.

Real-world user behaviors are rarely isolated actions; they manifest as intent flows governed by spatiotemporal dependencies [1], e.g., a user in cross-city travel may follow: [Request a ride]\(\rightarrow\)[Hotel check-in]\(\rightarrow\)[Nearby dining]\(\rightarrow\)[Return to hotel]. To provide integrated service recommendations, we define Generative Spatiotemporal Intent Sequence Recommendation (GSISR): generating intent sequences that are both logically coherent and physically executable under spatiotemporal constraints.

Existing paradigms are ill-equipped for GSISR. Sequential recommendation models [2], [3] focus on next-item probabilities and suffer from logical inconsistencies or repetitive loops when generating long-range sequences. The rise of LLMs has catalyzed a shift toward generative recommendation [4], [5], yet direct LLM deployment faces two key challenges: (1) Computational bottleneck—Chain-of-Thought (CoT) [6] reasoning incurs latency that exceeds production requirements; (2) Spatiotemporal hallucination—LLMs may lack access to application-specific spatiotemporal constraints, producing physically infeasible itineraries.

To address these challenges, we propose GPlan (“Guess What You Plan”), a framework that internalizes LLM-level planning into lightweight industrial models. GPlan comprises two core components: (1) Progressive Implicit CoT Distillation (PICD), which progressively compresses explicit teacher reasoning into reserved latent tokens, preserving expert-level logic while meeting online latency requirements; (2) Spatiotemporal Counterfactual DPO (SC-DPO), which constructs bidirectional preference pairs between matched and counterfactually-perturbed spatiotemporal contexts and applies a reference-anchored DPO objective [7] so that the model learns to change its plan when the context shifts. The framework is illustrated in Figure 1.

The main contributions are:

• We define the GSISR task and release an anonymized industrial dataset from Amap for research on logical coherence and physical feasibility in recommendation.

• We design PICD, a latent CoT distillation built around a multi-token reasoning scaffold and a compression-aware learning rate (CALR) that ties LR transitions to the state of the latent compression curriculum, enabling efficient student inference while preserving the implicit-CoT interface.

• We propose SC-DPO, a counterfactual preference-alignment objective whose reference-anchor, bounded-margin, and centered-drift terms introduce context-conditional preference without degrading the SFT-acquired planning ability.

2 Related Work↩︎

2.0.0.1 Sequential and generative recommendation.

Sequential recommenders model ordered behavior to predict future interactions; Transformer-based encoders such as SASRec [8] and BERT4Rec [9] capture short- and long-range dependencies, and recent reasoning-enhanced variants like ReaRec [10] explore latent multi-step computation. Generative recommendation reformulates outputs as natural-language tokens or semantic identifiers: P5 [11] unifies recommendation tasks under a text-to-text paradigm, TIGER [12] applies generative retrieval via autoregressively decoded semantic IDs, and HSTU [13] scales generative transducers to industrial settings. Recent surveys further summarize how LLMs are leveraged for semantic understanding, instruction following, and generative retrieval in recommender systems [2]–[5]. These methods typically optimize next-item prediction or generative retrieval, scoring each item independently. GSISR instead evaluates an ordered, parameterized sequence in which later actions may depend on the parameters and spatiotemporal context of earlier actions.

2.0.0.2 Efficient reasoning and preference alignment.

Chain-of-thought prompting improves LLM reasoning by surfacing intermediate steps before the final answer [6], but explicit CoT decoding is too slow for production. One line of work distills reasoning into smaller students that still emit explicit traces [14]–[19]; this preserves the reasoning text but does not reduce its length. A more recent line moves reasoning into latent or compressed representations and is differentiated by how CoT is replaced: ICoT-KD [20] aligns the student’s hidden states to the teacher’s reasoning trace; Stepwise Internalization [21] progressively removes reasoning tokens during training so the model learns to compute without emitting them; CCoT [22] replaces a long CoT with a fixed-length sequence of contemplation tokens; CODI [23] self-distills CoT into a continuous representation shared between explicit and implicit modes; and Coconut [24] reasons directly in latent space by recycling last-layer hidden states as next-step inputs. These approaches differ in how much of the CoT is replaced, whether the replacement is gradual or one-shot, and whether the latent slot is a single vector or a sequence of tokens. For preference alignment, DPO [7] optimizes directly on preference pairs without a reward model; in LBS recommendation, however, a fluent and semantically plausible plan can still violate temporal, spatial, or service-state constraints, motivating alignment objectives that explicitly target executable plans.

3 Preliminary↩︎

3.1 Problem Formulation↩︎

The GSISR task aims to generate an executable intent sequence that satisfies complex user needs in the Amap homepage agent.

Input Space: Let \(\mathcal{X} = \{u, \mathcal{H}, s, \mathcal{E}\}\) be the input context, where \(u\) is the user profile, \(\mathcal{H}\) the interaction history, \(s\) the spatiotemporal context, and \(\mathcal{E}\) the intent library.

Output Space: The goal is to generate a structured sequence of \(n\) parameterized intents \(\mathbf{Y} = \{a_1, a_2, \dots, a_n\}\). Each intent \(a_k = (v_k, p_k)\) is a parameterized tool invocation, where \(v_k \in \mathcal{E}\) is a tool from the intent library \(\mathcal{E}\) and \(p_k\) are its arguments.

Objective: Our goal is to learn a generative model \(f_\theta: \mathcal{X} \rightarrow \mathbf{Y}\). Formally, we aim to find the optimal parameters \(\theta^*\) that maximize the log-likelihood of generating curated target sequences from the dataset \(\mathcal{D}\): \[\theta^* = \arg\max_\theta \sum_{(\mathcal{X}, \mathbf{Y}) \in \mathcal{D}} \sum_{t=1}^{T} \log P(y_t \mid y_{<t}, \mathcal{X}; \theta)\] where \(T\) is the length of the serialized sequence \(\mathbf{Y}\) and \(y_t\) denotes its \(t\)-th token. Crucially, the dataset \(\mathcal{D}\) is constructed (see Sec. 3.2) to ensure that each curated target sequence \(\mathbf{Y}\) satisfies the physical constraints imposed by the spatiotemporal context \(s\) and the logical dependencies within \(\mathcal{E}\).

3.2 Human-in-the-loop Data Synthesis↩︎

Real-world LBS logs are sparse and noisy, making them impractical as direct training data for a sequence-recommendation task that requires logical coherence. We therefore design a Human-in-the-loop (HITL) pipeline to construct the GSISR dataset with logical depth and physical grounding.

We first extract high-value triggers from large-scale logs — log patterns that imply multi-step service needs, such as cross-city arrivals or active ride/hotel orders. After cleaning, domain experts at Amap perform logical calibration on the resulting trajectories, yielding a Seed Dataset of 1,000 “Intent–Environment–Logic” triplets that anchor the downstream synthesis with human-validated examples.

To scale beyond the seed, we employ a powerful teacher model (Qwen3-235B-A22B [25]) with few-shot prompting [26] and the Seed Dataset as in-context examples. The teacher autoregressively generates a structured reasoning path \(\mathbf{R}\) and intent sequence \(\mathbf{Y}\) conditioned on user profile \(u\) and spatiotemporal context \(s\).

Each generated sample then passes through a rule-based filter and is removed if any tier fails: (i) format checks — JSON parsability and a valid plan length; (ii) schema checks — every intent must use a tool from a fixed library, with required parameters present and enumerable fields restricted to their admissible values; and (iii) logic invariants — requiring every parameter reference (e.g., a destination consumed by a downstream action) to resolve to a producer intent earlier in the sequence, and bounding the count of mutually exclusive travel-class intents (e.g., at most one ride-hailing call per sequence). Across our synthesized candidates, \(28.9\%\) are removed, leaving the final \(100\,\text{K}\)-sample dataset \(\mathcal{D}\). The same filter is re-applied at evaluation time as a minimum validity check on any model’s output (Sec. 5).

3.2.0.1 Label Provenance and Scope of Supervision.

The 1,000 seed triplets are calibrated by Amap domain experts. The remaining large-scale targets are generated by Qwen3-235B-A22B using those seeds as in-context examples, and then filtered by the deterministic format, schema, and logic checks above. The seed set and the filter are therefore independent of the student model, but most training and offline evaluation targets are teacher-generated. We accordingly interpret the offline metrics in Sec. 5 as measures of teacher-aligned planning fidelity and dataset-defined feasibility rather than as standalone proof of user-valued recommendation quality. To add evidence that does not depend on the teacher, Sec. 5.3 uses an LLM judge that never sees the curated target sequence, and Sec. 5.5 reports the production A/B result against the incumbent CTR ranker.

4 Methodology↩︎

To internalize the reasoning capabilities of LLMs into a lightweight industrial model while improving sensitivity to spatiotemporal context, GPlan introduces two core components: Progressive Implicit CoT Distillation and Spatiotemporal Counterfactual DPO.

4.1 Progressive Implicit CoT Distillation↩︎

To bridge the gap between complex reasoning and real-time industrial requirements, we propose Progressive Implicit Chain-of-Thought Distillation (PICD), which distills LLM reasoning into deployable Small Language Models (SLMs) by compressing structured CoT into reserved latent tokens during training. Following the line of latent-CoT distillation surveyed in Sec. 2, PICD makes three design choices specific to industrial intent-flow recommendation: (i) a multi-token latent reasoning scaffold that preserves the semantic structure of the teacher’s CoT, (ii) a forward, per-block progressive compression schedule with a dynamic block count tied to plan length, and (iii) a compression-aware learning-rate schedule that aligns LR transitions with the changing reasoning representation. During training, a section-normalized loss keeps JSON-plan supervision at a fixed section-level weight as the CoT prefix is progressively shortened.

4.1.1 Expert Demonstration with Structured Reasoning↩︎

We synthesize an expert dataset in which the teacher LLM produces a structured reasoning path \(\mathbf{R}\) before the final intent sequence. \(\mathbf{R}\) has three types of semantic blocks: <CONTEXT> (contextual analysis), <STRATEGY> (planning strategy), and <STEP_\(i\)> (per-intent justification, repeated once per item in the JSON plan).

<THOUGHT>
<CONTEXT>Briefly analyze the current context and
the user's potential needs</CONTEXT>
<STRATEGY>Based on the context analysis, devise
the core strategy for the plan</STRATEGY>
<STEP_1>Focus on analyzing the primary and most
crucial intent</STEP_1>
...
<STEP_n>Explain why the n-th intent is
recommended</STEP_n>
</THOUGHT>

While structured CoT improves decision quality, its autoregressive generation cost is prohibitive under production latency constraints.

4.1.2 Latent Multi-Token Reasoning Scaffold↩︎

To reduce the autoregressive generation overhead of explicit CoT while preserving its structural information, PICD replaces each complete semantic block of \(\mathbf{R}\) with a fixed-length sequence of \(K\) reserved special tokens, keeping only the outer <THOUGHT>...</THOUGHT> wrapper. With \(K=3\), the fully latent prefix is compactly written as \[\Phi(\mathbf{R}) = \texttt{<THOUGHT>}\; C\,S\,T_1\cdots T_{|\mathbf{Y}|}\;\texttt{</THOUGHT>},\] where \(C=(c_a,c_b,c_c)\) encodes the context block, \(S=(s_a,s_b,s_c)\) encodes the strategy block, and \(T_i=(t_{i,a},t_{i,b},t_{i,c})\) encodes the \(i\)-th step block. These symbols denote distinct reserved vocabulary tokens, e.g., \(c_\cdot\) corresponds to <THOUGHT_CONTEXT_*>, \(s_\cdot\) to <THOUGHT_STRATEGY_*>, and \(t_{i,\cdot}\) to <T_\(i\)_*>. Thus the inner XML tags such as <CONTEXT> and <STEP_\(i\)> are removed once their blocks are compressed.

We choose \(K=3\) to give each latent block enough capacity for the multi-faceted content of one reasoning step: in a <STEP_\(i\)> block, the latent triplet jointly encodes tool selection, parameter assignment, and the link to the previous intent in the plan; in <CONTEXT> and <STRATEGY> it accommodates the user’s spatiotemporal situation and the high-level plan rationale. \(K\) is treated as a fixed architectural choice rather than a per-run hyperparameter.

Because the JSON plan length \(|\mathbf{Y}|\) varies across samples, so does the total number of latent blocks: \[B = 2 + |\mathbf{Y}|,\] where the constant \(2\) accounts for <CONTEXT> and <STRATEGY>. We track \(B\) dynamically per sample during training rather than padding to a fixed length, so samples with shorter plans require fewer blocks to reach full latent compression.

4.1.3 Forward Progressive Compression and Compression-Aware LR↩︎

4.1.3.1 Forward progressive schedule.

Across the \(N\) training epochs, blocks are replaced with their latent token triplets in forward order: <CONTEXT>, then <STRATEGY>, then <STEP_1>, <STEP_2>, and so on. This order matches the natural construction of an intent plan—first situate the user, then commit to a strategy, then expand into concrete steps. Let \(b(e)\) denote the number of leading blocks compressed at the start of epoch \(e\). Training proceeds through (i) an initial phase (\(b{=}0\)) replicating full-text CoT, (ii) a progressive phase (\(0{<}b{<}B\)) replacing the leading \(b\) blocks with latent triplets while the rest remain in text, and (iii) a fully implicit phase (\(b{\geq}B\)) with the entire reasoning prefix in latent form. Because \(B\) varies per sample, samples with shorter plans enter the fully-implicit phase earlier than longer ones.

4.1.3.2 Non-stationary distillation.

A subtle issue arises in scheduling the optimizer through this curriculum: the prediction target is non-stationary. As \(b\) grows, more of the CoT prefix becomes latent tokens, and the student must learn how those tokens encode the missing semantics. A standard monotonically decaying schedule (e.g., cosine over all \(N\) epochs) shrinks the LR before that latent structure is fully acquired, leaving artifacts such as repeated triplets, missing tokens, and out-of-order sequences in the emitted reasoning. Holding the LR constant throughout stabilizes the latent structure but leaves no low-LR phase in which to refine the JSON plan against its now-final latent input.

4.1.3.3 Compression-Aware LR (CALR)

CALR ties the LR schedule to the state of the compression curriculum. Recall that for a sample with \(B = 2 + |\mathbf{Y}|\) reasoning blocks, the prefix is fully latent once the global compression stage \(g(t)\) reaches \(B\); before that point, the model is still learning what each latent token should encode. We set the LR-transition target to \(B^\star = 9\), the empirical \(p_{90}\) of \(B\) across our training set, so that by the time the LR drops, most samples have already seen a fully latent prefix at least once. Concretely, CALR keeps a higher LR while the latent prefix is being formed and switches to a lower cosine-decayed LR once the latent representation is essentially stable: \[\eta(t) = \begin{cases} \eta_{\text{struct}} & g(t) \leq B^\star \quad \textit{(structure acquisition)} \\ \eta_{\text{polish}} \cdot \mathrm{cosine}(t-t^\star) & g(t) > B^\star \quad \textit{(semantic polish)} \end{cases}\] where \(t^\star\) is the first refinement step and \(\eta_{\text{struct}}>\eta_{\text{polish}}\). In our main runs \(\eta_{\text{struct}}=5\!\times\!10^{-6}\) and \(\eta_{\text{polish}}=1\!\times\!10^{-6}\). Intuitively, the first phase builds the latent token structure under a stable high LR; the second phase refines the JSON plan conditioned on the now-final latent prefix. Sec. 5.4.0.2 validates this design empirically.

4.1.3.4 Section-normalized training loss.

PICD changes the number of supervised CoT tokens over the curriculum: early examples contain full textual reasoning, whereas later examples replace more blocks with three-token latent triplets. Under standard token-level cross entropy, the relative weight of the JSON plan would therefore vary with the compression stage. We stabilize the objective by averaging within the CoT and JSON sections separately and combining them equally: \[\mathcal{L} = \frac{1}{2}\left(\mathcal{L}_{\mathrm{\small cot}} + \mathcal{L}_{\mathrm{\small json}}\right),\] where \(\mathcal{L}_{\mathrm{\small cot}}\) and \(\mathcal{L}_{\mathrm{\small json}}\) are mean token losses over their respective active sections. This keeps the JSON plan at a fixed section-level weight throughout progressive compression.

4.2 Spatiotemporal Counterfactual DPO↩︎

After supervised fine-tuning, the model has acquired basic user understanding, trajectory interpretation, and plan generation. Static supervision alone, however, is a weak signal for the conditional dependence of the plan on spatiotemporal context: the same user under weekday morning rush, weekend night, or a relocated current position should receive substantively different intent sequences, yet the SFT objective does not enforce this dependence. We therefore introduce Spatiotemporal Counterfactual DPO (SC-DPO), a post-training step that teaches the model how a change in context should reshape the generated plan.

4.2.1 Counterfactual Pair Construction↩︎

For each anchor sample, we construct two related contexts: an original context \(x\) and a counterfactual context \(x'\). The two share the user profile, long-term behavior summary, and main history; they differ only in spatiotemporal variables — current time, current location, current city, weekday/weekend flag, or holiday flag. Each context is paired with a teacher-generated, filter-passed plan produced by the pipeline in Sec. 3.2. We materialize the pair bidirectionally: under prompt \(x\), the \(x\)-matched plan is chosen and the \(x'\)-matched plan is rejected; under prompt \(x'\), the comparison is reversed. This symmetry is essential because the rejected plan is not globally invalid; it is only wrong for the current context, and forcing the model to flip its preference when the context flips trains it to learn “match the context” rather than “always avoid the counterfactual plan”.

For input \(x\), the matching response is denoted \(y_+\) and the response matched to the alternative context \(x'\) is denoted \(y_-\). Crucially, \(y_-\) is a context-mismatched response, not a globally low-quality one: it would be a perfectly valid plan under \(x'\), but does not fit \(x\). This distinction motivates the loss design below.

4.2.2 Reference-Anchored Optimization Objective↩︎

4.2.2.1 Why standard DPO is insufficient.

Standard DPO treats a \((y_w, y_l)\) pair as an absolute preference and rewards the policy for continually widening the log-likelihood gap. Applied directly to counterfactual pairs, this would push \(\pi_\theta(y_-\mid x)\) arbitrarily low even though \(y_-\) is a valid plan in its own context. The model would not only learn context-conditional preference but also degrade the general planning ability acquired during SFT.

4.2.2.2 Four-term intuition.

SC-DPO uses four loss terms because a counterfactual negative is not an ordinary low-quality response. The DPO term creates the desired local preference: under context \(x\), the \(x\)-matched plan should receive a higher score than the \(x'\)-matched plan. The anchor term prevents this preference update from lowering the probability of the matched plan and degrading the SFT-acquired planning ability. The gap and center terms together prevent the model from satisfying the DPO term by globally suppressing the probability of \(y_-\): the gap keeps the preference margin positive but bounded, while the center keeps the average reward shift of the pair close to the reference policy. We now formalize each term.

4.2.2.3 Reward shifts.

Let \(\pi_{\text{ref}}\) be the SFT model and \(\pi_\theta\) the model being optimized. For each counterfactual pair \((x, y_+, y_-)\), define the reward shift of each response relative to the reference (with DPO temperature \(\beta_{\text{DPO}}\)): \[\begin{align} r_+ &= \beta_{\text{DPO}} \bigl[\log \pi_\theta(y_+ \mid x) - \log \pi_{\text{ref}}(y_+ \mid x)\bigr], \\ r_- &= \beta_{\text{DPO}} \bigl[\log \pi_\theta(y_- \mid x) - \log \pi_{\text{ref}}(y_- \mid x)\bigr]. \end{align}\]

4.2.2.4 Preference term.

As in DPO, the preference term encourages a positive margin between matched and mismatched responses: \[\mathcal{L}_{\text{DPO}} = -\log \sigma(r_+ - r_-).\]

4.2.2.5 Reference anchor.

To prevent SFT-acquired planning ability from drifting during DPO, we anchor the matched response to the reference policy with a hinge penalty (with margin \(\delta\)): \[\mathcal{L}_{\text{anchor}} = \max(0, \delta - r_+)^2.\] This term requires that \(\pi_\theta(y_+ \mid x)\) does not fall meaningfully below \(\pi_{\text{ref}}(y_+ \mid x)\); we set \(\delta=0\) in the main runs. The model is therefore not allowed to sacrifice the correct response under \(x\) to amplify the margin against \(y_-\).

4.2.2.6 Bounded margin and centered drift.

To prevent the model from gaming the preference term by collapsing \(y_-\), we constrain both the preference margin \(\text{gap} = r_+ - r_-\) and the pair’s overall reward drift \(\text{center} = \tfrac{1}{2}(r_+ + r_-)\): \[\begin{align} \mathcal{L}_{\text{gap},\ell} &= \max(0, \gamma_\ell - \text{gap})^2, \\ \mathcal{L}_{\text{gap},h} &= \max(0, \text{gap} - \gamma_h)^2, \end{align}\] \[\mathcal{L}_{\text{center}} = (\text{center} - m)^2.\] \([\gamma_\ell, \gamma_h]\) defines the desired range of the preference margin — positive, but not unbounded — and the two gap components allow asymmetric penalties for falling below the lower bound versus exceeding the upper bound. The center target \(m\) (set to \(0\) in our experiments) keeps the pair-level reward drift near the reference, so the loss does not encode a global “\(y_-\) is bad” signal.

4.2.2.7 Final objective.

\[\mathcal{L}_{\text{SC-DPO}} = \mathcal{L}_{\text{DPO}} + \lambda_a\,\mathcal{L}_{\text{anchor}} + \lambda_{g,\ell}\,\mathcal{L}_{\text{gap},\ell} + \lambda_{g,h}\,\mathcal{L}_{\text{gap},h} + \lambda_c\,\mathcal{L}_{\text{center}}.\] The four loss components address distinct concerns of the counterfactual setting: \(\mathcal{L}_{\text{DPO}}\) provides the preference signal; \(\mathcal{L}_{\text{anchor}}\) protects the SFT-acquired planning ability on matched responses; and the gap and center components encode that the desired behavior is a bounded, context-conditional preference rather than absolute aversion to \(y_-\).

Conceptually, SC-DPO teaches the model not only “which plan is better” but “why the same user warrants a different plan when time or location shifts”. It is best understood as a post-training step that makes the model change its plan when the user’s time, location, or trip state changes; its contribution is most pronounced on metrics sensitive to context responsiveness, while offline label metrics also improve modestly (Sec. 5.4).

5 Experiments↩︎

5.0.0.1 Scope of evaluation.

Following the label-provenance discussion in Sec. 3.2, our offline metrics in Sec. 5.2 measure (i) how faithfully a deployable student recovers the structured planning behavior captured in our curated dataset and (ii) the structural validity of generated sequences. They complement, but do not substitute for, recommendation utility, which we measure via an independent LLM judge (Sec. 5.3) and via the online A/B test in Sec. 5.5 against the production CTR-based ranking incumbent.

5.1 Experimental Settings↩︎

5.1.1 Datasets and Baselines.↩︎

We conduct experiments on a large-scale industrial dataset comprising 100,000 intent flows from Amap (with 1,000 held out as the test set), constructed via the pipeline described in Sec. 3.2. We compare GPlan (1.7B and 4B versions) against two categories of baselines: (1) traditional sequential models: SASRec [8], BERT4Rec [9] and a reasoning-based model ReaRec [10]; (2) generative recommendation models: P5 [11], TIGER [12]. All baselines are adapted to the full intent sequence task: SASRec, BERT4Rec, and ReaRec are trained to predict the next atomic intent ID; P5 and TIGER decode intent IDs autoregressively as text or semantic tokens. None of these baselines emit parameter slots, so they are evaluated on tool-level match only. Our GPlan models use the Qwen3 1.7B and 4B backbones.

5.1.2 Evaluation Metrics↩︎

We evaluate GSISR offline via three dimensions: (1) Acc@1, measuring the accuracy of the first intent, which is prioritized in Amap’s homepage UI; (2) NDCG [27], assessing the ranking relevance of the entire sequence; and (3) normalized edit similarity (NES), which evaluates the structural alignment between the predicted and ground-truth intent sequences. It is defined as: \[\text{NES}(\hat{S}, S^*) = 1 - \frac{D(\hat{S}, S^*)}{\max(|\hat{S}|, |S^*|)}\] where \(D\) is the weighted Levenshtein edit distance with insertion and deletion costs of \(1.0\), a tool-level substitution cost of \(1.0\) (different tool name), and a parameter-level substitution cost of \(0.3\) (same tool, different parameters). \(\text{NES} \in [0,1]\), where higher values indicate better sequence-level alignment.

5.1.3 Implementation Details.↩︎

GPlan uses the Qwen3 1.7B and 4B backbones. PICD trains for \(13\) epochs with \(K=3\) latent tokens per block, \(B^\star = 9\), \(\eta_{\text{struct}} = 5\!\times\!10^{-6}\), and \(\eta_{\text{polish}} = 1\!\times\!10^{-6}\). SC-DPO is initialized from the PICD-CALR checkpoint and trained for \(1\) epoch on the counterfactual pair corpus at learning rate \(2\!\times\!10^{-7}\) (constant with warmup ratio \(0.03\)), with \(\beta_{\text{DPO}} = 0.20\), anchor margin \(\delta = 0\) and weight \(\lambda_a = 5\), gap range \([\gamma_\ell, \gamma_h] = [0.10, 0.20]\) with asymmetric weights \(\lambda_{g,\ell} = 10\) on the lower bound and \(\lambda_{g,h} = 2\) on the upper bound, and center target \(m = 0\) with weight \(\lambda_c = 3\).

5.1.3.1 Latent-Structure Validity.

In addition to task metrics, we report a deterministic diagnostic specific to PICD that measures whether the emitted latent reasoning prefix is well-formed. A predicted output is counted as latent-valid if it contains a single <THOUGHT>...</THOUGHT> block whose latent tokens (i) follow the scaffold order \(C,S,T_1,\ldots,T_{|\mathbf{Y}|}\) defined in Sec. 4.1.2, (ii) contain no repeated or out-of-order tokens, (iii) leave no residual raw XML tags such as <STEP_\(i\)>, and (iv) yield a step count equal to the JSON plan length \(|\mathbf{Y}|\). We use this diagnostic to surface latent-structure failures that JSON-based metrics cannot detect (Sec. 5.4.0.2).

5.2 Main Results↩︎

As shown in Table 1, GPlan consistently outperforms both traditional sequential baselines and generative recommendation baselines across the deployed sizes. The substantial gap in Acc@1 (\(+18.5\) percentage points of GPlan-4B over TIGER) suggests that sequential models struggle to capture the complex spatiotemporal constraints and logical dependencies in intent flows. Notably, GPlan-1.7B retains the bulk of GPlan-4B’s accuracy (\(60.5\) vs.\(62.7\) Acc@1), demonstrating that our distillation strategies effectively internalize complex reasoning capabilities into smaller architectures.

5.3 Independent Evaluation by LLM Judge↩︎

Label-based metrics measure how closely a model reproduces curated targets, but not whether the resulting plan is itself a good recommendation. We therefore complement them with an LLM judge (GPT-4o, temperature 0) that scores each candidate sequence on three semantic axes directly tied to GPlan’s claims. The judge sees only the user context and the candidate plan, never the curated target sequence. All GPlan variants additionally pass the rule-based filter of Sec. 3.2 (JSON, schema, mutual-exclusion, no-repetition), so we focus the LLM-judge tables on the more discriminating semantic axes.

The rubric is calibrated so that a safe but generic plan receives 3, not 5: getting above 3 requires positive evidence on the axis, while a score below 3 requires an explicit failure. This quality-driven calibration produces a meaningful spread of scores across models rather than ceiling saturation, which we observed under earlier failure-driven rubrics that defaulted to 5.

A residual risk is that an LLM judge may reward superficial mentions of context (e.g., a plan that names the current POI without actually using it for tool or parameter selection) even when the plan does not truly use the context. We reduce, but do not eliminate, this risk by scoring concrete axes that inspect ordering, tool choice, parameter ranges, and fit to the current POI/time/order state. The online A/B result in Sec. 5.5 provides a complementary signal that does not rely on LLM judgement.

Because non-generative baselines (SASRec, BERT4Rec, ReaRec, P5, TIGER) emit ID-only sequences without the parameter slots the rubric inspects, the judge is applied only within the GPlan family, where it differentiates training paradigms rather than backbone capacity. The per-axis scores together with their mean Overall are reported alongside the label-based metrics in Table 2 (Sec. 5.4); a targeted slice for the SC-DPO design appears in Table 4.

5.4 Ablation Analysis↩︎

5.4.0.1 Effectiveness of Learning Strategies.

To verify the contribution of each component, we compare GPlan-4B with three variants: (1) Direct-SFT (no reasoning); (2) CoT-SFT (explicit text reasoning); and (3) PICD, our latent distillation strategy. We also evaluate the effect of adding SC-DPO. Table 2 reports both label-based metrics (Acc@1, NDCG@3, NES) and the LLM-judge axes (Flow, Logic, Spatiotemporal (ST), and their mean Overall; Sec. 5.3) on the same rows. Two patterns emerge. First, PICD matches the plan quality of CoT-SFT despite removing the explicit reasoning text: it is comparable to CoT-SFT on the label-based metrics and improves across all three judge axes, indicating that latent compression does not reduce reasoning quality. Second, adding SC-DPO on top of PICD shifts gains toward the spatiotemporal axis specifically while keeping the other axes and the label metrics stable, consistent with its design as a grounding-oriented post-training step rather than a generic accuracy optimizer.

5.4.0.2 Compression-Aware LR vs.Single-Phase Schedules.

Table 3 reports one representative run for each LR regime in PICD (Sec. 4.1.3). Cosine LR is the standard monotonic-decay choice, which reduces the learning rate before the latent scaffold has been fully acquired. Constant LR keeps the structure-learning rate throughout training, which stabilizes the scaffold but offers no lower-LR phase for refining the JSON plan. CALR separates these two phases explicitly. In addition to the sequence-level label metrics, we report Latent-Valid (Sec. 5.1.3.1) as a sanity check on whether the implicit-CoT interface itself is preserved end-to-end; the criterion is deliberately strict, so it functions as a pass/fail gate rather than a fine-grained quality score. We read the table as follows: cosine LR achieves competitive task metrics, but the emitted prefix no longer satisfies the scaffold (the model effectively recovers a serviceable JSON plan while bypassing the intended latent interface). Constant LR and CALR both preserve the scaffold; among the two, CALR additionally improves the label-based metrics by retaining a lower-LR refinement phase. Phase-aware dynamic weighting on the section-normalized loss was also tried but did not consistently improve over the static \(1{:}1\) combination once CALR is in place, and is therefore not used by default.

5.4.0.3 Reference-Anchored vs.Vanilla DPO.

To isolate the contribution of the reference-anchored design in SC-DPO (Sec. 4.2), we ablate against (i) no DPO at all (PICD-CALR only) and (ii) a vanilla DPO variant that omits the anchor / gap / center regularization terms but uses the same counterfactual pair construction. All three variants share the same SFT backbone (PICD with CALR) and the same counterfactual training corpus; only the post-training loss differs. Beyond label-based metrics, we report the LLM-judge ST axis — the operationally relevant axis for SC-DPO’s grounding motivation — and the judge Overall as a guard against improvements on ST that come at the cost of the other two axes.

Table 4 isolates whether the anchor / gap / center terms preserve the SFT-acquired matched-response quality while introducing context-conditional preference. SC-DPO treats \(y_-\) as context-mismatched rather than globally low-quality, so its primary operational signature is a stronger judge ST score without reducing the judge Overall or the label-based metrics. Vanilla DPO, by pushing \(\pi_\theta(y_- \mid x)\) down without constraint, instead drifts downward across all reported axes, confirming the need for the anchor / gap / center regularization.

5.4.0.4 Inference Efficiency.

We evaluate the deployment feasibility by measuring mean response time (RT) across the deployable scales and methods. All numbers are measured on two NVIDIA H20 GPUs under a target serving load of QPS \(=10\), with greedy decoding. As shown in Table 5, while CoT-SFT provides strong reasoning, its latency (up to \(1.85\) s at 4B) is incompatible with real-time production. Our PICD achieves a \(3.7\times\) speedup over CoT-SFT at the 4B scale, maintaining an RT close to Direct-SFT. This gives PICD a favorable accuracy/latency operating point for industrial deployment.

5.5 Online A/B Testing↩︎

GPlan was deployed to the Amap homepage in an A/B test against the incumbent CTR-based ranking model, using GPlan-1.7B as the serving model. The test ran for 14 consecutive days. Two parallel slices were run: a general slice on \(5\%\) of homepage traffic (\(\sim 600\) QPS), and a separate cross-city slice on another \(5\%\) that isolates users with an active out-of-town context. The general slice yielded a \(+0.87\%\) UV-CTR lift over the production baseline, while the cross-city slice yielded a \(+1.04\%\) UV-CTR lift, indicating that GPlan’s gains are larger in high-value spatiotemporal scenarios where sequence-level planning matters most.

6 Conclusion↩︎

We formalized GSISR — generating coherent, physically executable intent sequences under spatiotemporal constraints — and proposed GPlan to internalize LLM-level planning into deployable students. PICD combines a multi-token latent reasoning scaffold with a compression-aware learning rate that ties LR transitions to the state of the latent compression curriculum, preserving the implicit-CoT interface while refining the JSON plan at production latency. SC-DPO introduces reference-anchor, bounded-margin, and centered-drift terms on top of counterfactual preference pairs, so the model learns context-conditional preference without degrading the SFT-acquired planning ability. Online A/B tests on Amap homepage confirm that GPlan delivers measurable user-side gains over the production CTR-based ranker, with a larger lift on high-value cross-city scenarios where sequence-level planning matters most. Future work will explore reinforcement learning and multi-turn user feedback to further improve personalization and long-horizon adaptability.

References↩︎