LLMs have gotten surprisingly competent at the core task of research projects: reading papers, writing code, and turning messy thoughts into structured text. That naturally raises a question I couldn’t stop thinking about:

If I compress the entire research loop into a single weekend—survey → idea → implementation → experiments → write-up—how far can I get with LLMs as a co-pilot?

This post is that experiment.

I’m going to try it on the Quadratic Assignment Problem (QAP): an NP-hard optimization problem that’s notoriously hard. QAP is a “permutation” problem (like TSP), but the objective is quadratic, choices interact with each other in a way that quickly becomes globally entangled. Many well-known combinatorial problems can be expressed as special cases or close relatives of QAP, including variants related to routing, matching, layout, and assignment.

Despite that importance, QAP has received much less attention in neural combinatorial optimization than problems like TSP. One reason is practical: QAP is harder to “package” into the neural architectures that work nicely for other permutation problems. The signal you need depends on a lot of pairwise interactions, so learning good local decisions from partial context is simply harder. I’ll unpack this properly later, because it’s exactly where a new model design might help.

So the goal is simple and slightly reckless:

Can I, with the help of LLMs, produce a working neural method for QAP in a single weekend? And if I can, how competitive will it be? We’ll find out.

Preliminaries

Before diving into the sprint, a quick note on how I’ll run it.

This is a time-boxed project: the point is not to claim a polished, state-of-the-art solver, but to see what kind of research artifact can be produced under extreme constraints with modern LLM support. The output I’m aiming for is:

• a working implementation,
• a reproducible experimental setup,
• and a coherent write-up (call it a short paper or technical report).

I’ll use the following tools:

• ChatGPT (GPT-5.2 Thinking) for quick literature scanning, problem framing, and architecture brainstorming.
• Codex (gpt-5.3-codex) for coding iterations and refinements.
• Prism (LLM-assisted LaTeX projects) for the final report formatting.

Let’s start.

Stage 1: Literature Review

Before reading papers, I wanted to make sure I had the QAP formulation fresh in my mind. It’s been a while, so I simply asked the LLM for a quick refresh.

Q. Remind me of the Quadratic Assignment Problem (QAP) formulation.

A. The Quadratic Assignment Problem (QAP) assigns $n$ facilities to $n$ locations. Let:

• $F \in \mathbb{R}^{n\times n}$ be the flow matrix, where $F_{ij}$ quantifies the interaction between facilities $i$ and $j$.
• $D \in \mathbb{R}^{n\times n}$ be the distance matrix, where $D_{ab}$ is the distance between locations $a$ and $b$.
• $\pi \in S_n$ be a permutation, where $\pi(i)$ is the location assigned to facility $i$.

The QAP objective is:

Equivalently, using a permutation matrix $P \in {0,1}^{n\times n}$ with $P_{i,\pi(i)}=1$ and the feasible set $\Pi$ of all permutation matrices:

where the Frobenius inner product is:

Next, I asked the LLM to do what I’d normally do first: a fast literature scan, focused specifically on neural / deep learning methods for QAP.

Q. Give me a concise literature review of deep learning approaches for the Quadratic Assignment Problem (QAP): main method families, key papers, benchmarks/baselines, and the most promising gaps to explore.

A. (Literature review.)

After a fairly broad scan (24 minutes, 277 sources), it returned a structured summary and a handful of recent papers that were new to me.

For this project, I want to isolate what a neural policy can do without leaning on an external metaheuristic. Those hybrid pipelines are often excellent in practice, but they also blur the real potential of a neural solver, treating it as a neural component inside a classical solver.

So I’ll treat the following as hybrid baselines rather than the main object of study:

• (explicit tabu-search backbone; the network primarily provides an initialization)

• (explicit inference-time MCMC finetuning/adaptation)

Instead, the most relevant direction for me is the learn-to-improve family, especially —because it looks structurally close to what makes classical QAP solvers strong: swap-based improvement trajectories.

I’ll start from methods with public code so the comparisons are not based on re-implementations:

• — alexnowakvila/QAP_pt

• — Thinklab-SJTU/ThinkMatch (NGM model folder)

• — psbagga17/drlqap

• — Thinklab-SJTU/RGM

• — PKUTAN/SAWT

A key point already shows up here: these baselines actually split into two partially different “QAPs” in practice:

• facility-layout / Koopmans–Beckmann settings (often geometry-structured),
• Lawler-QAP / graph matching settings (affinity-driven, association-graph flavored).

Stage 2: Gaps within Neural QAP

The literature report came back with the usual “checkbox gaps”: scalability beyond small $n$, generalization to QAPLIB, hybridization with exact solvers, lack of standardized benchmarks, and a “theory and guarantees” bucket (help!). All true, but also a bit too generic.

What I did take seriously is the evaluation angle. Seems like QAP papers often look hard to compare because each one uses different evaluation protocols: different instance generators, different time budgets, different baselines. So rather than jumping straight into model design, I decided to first produce a clean benchmark + reproducible baselines.

That said, I didn’t want this weekend to become an exercise of reviewing theoretical proofs, or re-implementing plain tabu search for the tenth time. My point is to explore something algorithmic: a representation choice, an inference procedure, or a learning pipeline that is genuinely better aligned with QAP’s structure.

So I asked the LLM again:

Q. Ignore generic “future work” (scale, more benchmarks, theory). Based on existing neural QAP methods, list 5–8 specific, mechanism-level gaps and a concrete improvement for each.

A. It came with a bunch of interesting gaps, here the most interesting ones in my opinion:

• “What problem are we solving?” (KB-QAP vs Lawler-QAP mismatch). Several neural papers labeled as “QAP” are really solving different formulations (layout-flavored KB-QAP vs matching-flavored Lawler-QAP). This makes comparisons misleading unless the benchmark is explicit about which regime it targets. Some neural pipelines implicitly rely on coordinates and Euclidean geometry (a habit from TSP). In QAP, and particularly in QAPLIB, $D$ is often just an arbitrary cost matrix (grid/manhattan, random, structured, etc.), so a coordinate-based inductive bias can break silently.

• Association-graph materialization blows up memory. Methods that build the full association graph quickly hit GPU-memory limits as $n$ grows, making large QAPLIB instances impractical.

• Constructive RL tends to be underpowered unless it gets strong structure priors. Constructive decoders face hard credit assignment because early choices interact quadratically with everything that comes later. This is visible in small-$n$ RL papers that do not scale cleanly.

• Additive scoring/energy misses quadratic coupling. Surrogates that score assignments as $\sum_i \phi_{i,\pi(i)}$ cannot represent the true quadratic interactions, biasing move ranking and exploration, especially on dense instances.

• Sparse/ambiguous reward in learn-to-improve RL. Treating non-improving steps as “zero signal” (and not explicitly penalizing worsening moves) makes plateaus look identical and wastes steps under tight budgets.

Stage 3: The Proposal: Architecture and Training/Inference Recipe

Before touching model design, I implemented the classical baselines (greedy construction + swap local search), neural baselines (RGM , SAWT ) and a synthetic evaluation pack. This gave me a stable loop: generate instances → run solver under a fixed step budget → report objective / gap / runtime.

A minimal neural-improvement starting point

The first neural baseline is deliberately simple: a swap-based neural improvement policy.

• State: an incumbent permutation $\pi$ (starting from a sequential initialization).
• Action: choose a swap $(i,j)$ and apply it.
• Rollout: fixed horizon of $T=4$ steps.
• Training: RL on improvement trajectories (Normalized improvement over $T$ steps as reward).

The main design question then became: what inductive bias should the policy have to pick good swaps reliably?
Instead of trying to design the final model in one shot, I iterated quickly with a coding agent: propose a modification, implement, train a short run, keep the changes that improve the validation curve.

Below is a compact log of the most informative iterations (validation on 100 instances of size $n=5$, reporting the best gap to optimal % after 20 steps).

Iteration log

1) Baseline swap policy (trained on $n=5$)

Result (gap to optimal @ $n=5$): 1.8522%
What it is: a basic swap policy trained end-to-end with RL, without strong QAP structure injected.

2) Min–max instance normalization

Result (gap to optimal @ $n=5$): 1.6824%
Change: normalize the instance matrices (flow and distance) with min–max scaling.
Why it helped: reduced sensitivity to absolute scale and improved optimization stability.

3) hetero_rel_transformer (2$n$ heterogeneous tokens + relational attention)

Result (gap to optimal @ $n=5$): 1.5965%
Change: represent each instance with 2$n$ tokens:

• $n$ facility tokens + $n$ location tokens,
  and inject instance structure via relation-biased attention (flows on facility–facility edges, distances on location–location edges, assignment links on cross edges).
  Why it helped: forced the policy to treat QAP structure as pairwise relations rather than flat features.

4) hetero_rel_transformer v2 (solution-aware relations + stronger attention control)

Result (gap to optimal @ $n=5$): 1.1659%
Changes (core ones):

• add induced distance $D_{\pi(i)\pi(j)}$ as a first-class relation feature,
• add per-head gates that balance content attention ($qk$) vs relation bias,
• optionally modulate value aggregation with relation features.
  Why it helped: made the encoder explicitly solution-aware in the same way swap delta computations are.

5) +1 dual-encoder layer (facility-only + location-only pre-encoding)

Result (gap to optimal @ $n=5$): 1.0301%
Change: before the 2$n$ hetero encoder, run a small “static” encoder:

• facility-only attention over $F$,
• location-only attention over $D$, then fuse these static embeddings with the dynamic (solution-conditioned) tokens.
  Why it helped: improved token quality by encoding within-type structure (flow communities, distance geometry) before mixing types.

6) Pre-norm GTLayer + relation features as both bias and gate (e1/e2)

Result (gap to optimal @ $n=5$): 0.6666%
Change: switch the main layers to a pre-norm transformer where relation features affect attention in two ways:

• e1: additive bias on attention logits,
• e2: multiplicative gate on attention probabilities (relation-conditioned filtering).
  Why it helped: the model can learn both which relations matter (gate) and how strongly (bias), which is closely aligned with swap evaluation.

7) +3 static (pre) layers (stronger dual encoder)

Result (gap to optimal @ $n=5$): 0.5694%
Change: deepen the static pre-encoder (3 layers).
Observation: more capacity helps in-distribution, but can start to over-specialize and hurt out-of-distribution generalization.

8) hetero_rel_transformer_3n_assign_pairwl (3$n$ tokens + explicit assignment tokens + pairwise reasoning)

Result (gap to optimal @ $n=5$): 0.3677%
Change: move from 2$n$ to 3$n$ tokens by adding an assignment token $A_i$ for each facility:

• $F_i$ (facility token), $L_a$ (location token), and $A_i=(i,\pi(i))$ (current assignment token).
  Then decode swaps with a pair-state module (PairWL): an approximate 2-WL-style update over assignment-token pairs $(i,j)$ using triadic composition $\sum_k (i,k)\circ(k,j)$.
  Why it helped: swap choice is inherently pairwise; making pair structure explicit reduces the burden on facility embeddings.

9) --pairwl_use_token_feedback

Result (gap to optimal @ $n=5$): 0.3128%
Change: add pair-to-token feedback, pooling pair states around each assignment token and writing back into token embeddings.
Why it helped (and hurt): improves in-distribution consistency, but can increase coupling and reduce robustness when scaling.

10) --pairwl_use_relation_aware_triad + --pairwl_use_strong_token_feedback

Result (gap to optimal @ $n=5$): 0.2972%
Changes:

• make the triadic composition relation-aware by gating intermediate nodes $k$ using learned functions of local pair features,
• strengthen the token feedback pathway (optionally top-$k$ pooling).
  Why it helped: pushes the pair module closer to swap-delta reasoning, where triadic context is filtered by instance- and solution-dependent cues.

To summarize the effect of these design iterations, the next Figure shows the best validation gap found on 20 steps (on $n=5$) after each architecture update.

What I take from these iterations

1) The best improvements came from features that mimic how swap local search evaluates moves:

• induced distances under the incumbent ($D_{\pi(i)\pi(j)}$),
• strong control of relation influence (bias + gate),
• explicit pair reasoning when decoding swaps.

2) Extra capacity helps, but only if it reinforces the right structure.
The 3N + PairWL variants are slower, but they improved generalization markedly at larger $n$ under the same step budget.

In the next stage, I’ll formalize the evaluation protocol and compare these variants against the basleines under consistent budgets.

Stage 4: Experiments and Evaluation Protocol

After several architecture iterations, the next step is to evaluate under a more realistic protocol: more test instances, multiple sizes, and direct comparison against both learned and classical baselines.

We use our model trained exclusively on instances of size $n=5$. However, we will now evaluate their generalization to larger sizes: $n \in {5,10,15,20}$.

Baselines

We compare against four baselines that cover both “neural” and “classical” points of reference:

• Learned baselines: RGM (neural constructive trained on $n=20$) and SAWT (neural improvement trained on $n=20$).
• Greedy constructive: a simple non-learned heuristic that builds a permutation once.
• Swap local search: a classical improvement baseline operating in the same 2-swap neighborhood, run until getting stuck in a local optima.

We report anytime performance (best-so-far objective versus time).

Results show a clear pattern: the policy trained on $n=5$ remains competitive on $n=5$ and exhibits non-trivial transfer to larger sizes. Under the same evaluation budget, it achieves the strongest final objective among the tested baselines, indicating that the improvements learned in the small regime are not purely size-specific.

Stage 5: Wrapping up

I did not expect the final outcome to look this strong.

The most surprising part is not that a neural model can learn to propose useful swaps, that is plausible in hindsight, but that the iteration loop was fast enough to make that progress in a couple of days. In the past, I had explored similar ideas, but the cost of implementation details (plumbing, debugging, profiling, refactors) made each iteration way longer. Ideas accumulated in unfinished branches and abandoned folders, long before reaching a clean evaluation protocol.

This time, the workflow was different: iterate on the architecture and training loop quickly, validate with a tight benchmark, keep only the changes that move the curve. That speed changes what is feasible.

There is a trade-off, though. Delegating implementation to a coding agent reduces friction, but it also reduces direct contact with every line of code. That loss of “full manual control” is not free: it can hide bugs, bake in unexamined assumptions, and make it easier to mistake artifacts for progress. The right posture is to embrace the speed while staying disciplined about verification.

I initially planned to end with a short, paper-like write-up, but the results were promising enough to justify a more complete treatment. Instead, I’m turning this into a proper article: cleaner experimental design, stronger baselines, and a thorough set of benchmarks and ablations to pinpoint what actually drives the gains. More soon.

Neural Combinatorial Optimization (NCO) often gets introduced through constructive models: a policy that builds a solution from scratch, one decision at a time. Neural Improvement (NI) flips the script: start from an existing solution and repeatedly apply small edits that make it better.

The Traveling Salesperson Problem (TSP) will be our playground to explain NI.

A TSP instance with $N$ cities is a set of coordinates

A tour is a Hamiltonian cycle, commonly represented as a permutation $\pi\in S_N$, with cyclic indexing $\pi_{N+1}=\pi_1$. The tour length is

In NI, we also define a move operator $\Phi$ (e.g., 2-opt), and an action $a_t$ that selects a particular move. Starting from an initial tour $\pi^{(0)}$, NI produces a sequence

Given a step budget $T$, the goal is to quickly drive the tour cost down.

One sentence mental model: NI is a learned local-search heuristic whose policy is applied repeatedly; scale generalization asks whether that heuristic remains valid when $N$ grows.

Why scale generalization is hard

If you train on TSP instances with $N\in[20,100]$, you’d love the same learned improver to work on $N=500$ or $N=1000$. That is the cross-scale generalization problem.

1) The action set grows with $N$

In plain terms: at $N=50$ you might have a handful of obviously good 2-opt moves; at $N=500$, you have many plausible moves, and the best ones can be annoyingly close.

2) The state distribution shifts with $N$

A random tour at $N=50$ looks different than at $N=500$. So does a “partially improved” tour after $t$ edits. The density of crossings, typical edge lengths, and the distribution of “available easy wins” all change.

So even if your architecture can technically process any $N$, the model still faces a distribution shift:

3) The horizon grows

If your inference budget scales like $T(N)=4N$ for example, then the policy is used for much longer rollouts on large instances. Small systematic biases that are harmless at $N=50$ can compound at $N=500$.

2-step imitation learning across sizes

Let’s think how could we train a NI policy using imitation learning (IL).

We could build a “teacher” that chooses the best move, then train a network to imitate it. But in NI, a myopic teacher can be misleading because some moves are “setup moves” that enable better improvements later.

That motivates a k-step optimal teacher. Let’s use k=2 to start.

Let $s=(X^{(N)},\pi)$ be the state. For a first action $a_1$, define the 2-step lookahead value

Then the teacher action is

Your IL objective becomes

A simple “setup move” example

Suppose three candidate first moves have immediate improvements:

• $a$: improves by $+1.0$, but then nothing good remains $\Rightarrow$ total $+1.0$.
• $b$: improves by $+0.2$, but unlocks a second move of $+3.0$ $\Rightarrow$ total $+3.2$.
• $c$: improves by $+0.8$, then $+0.1$ $\Rightarrow$ total $+0.9$.

A greedy teacher picks $a$. A 2-step teacher picks $b$.
So 2-step IL teaches “planning” even in a local-search setting.

A useful tweak is soft imitation:

Why this matters for scale: the number of near-tied 2-step choices tends to increase with $N$, so one-hot labels become brittle. A soft teacher distribution can stabilize training.

What to measure and how to stress-test

If your goal is cross-scale generalization, you want evaluations that separate “works on the training distribution” from “learned the right invariances and planning heuristics”.

1) Cross-scale rollout curves (anytime performance)

For each $N$, plot best-so-far tour length versus steps $t$, normalized by a strong reference:

The reference can be a classical solver/heuristic (or best-known on synthetic benchmarks).

The key is not only final gap, but how the curve degrades as $N$ increases.

2) Teacher consistency across sizes

If the teacher changes implementation with $N$ (e.g., exact depth-2 at small sizes, approximate at large sizes), quantify the discrepancy on overlapping sizes. This helps you separate “student failed to generalize” from “teacher changed”.

3) Start from different initializations

NI performance depends heavily on the initial tour distribution: random, greedy, constructive neural, POMO-style sampling, etc. Cross-scale generalization can look strong from one initializer and collapse from another.

A simple takeaway: changing the initializer changes the state distribution, and the learned improver is only as robust as the diversity of states it saw during training.

References

Combinatorial optimization (CO) sits underneath a huge range of real systems: routing and logistics, scheduling, allocation, packing, and graph problems such as partitioning or cuts. What makes these problems challenging is not that the objective is mysterious, but that the number of feasible solutions typically grows combinatorially with instance size.

Classical solvers and heuristics are the result of decades of human algorithmic effort. They are not “generic black boxes”: they encode substantial problem structure and domain knowledge—which neighborhoods to search, which relaxations to solve, which cuts to add, which branching rules work, which invariances matter, which parameters to tune. This accumulated craft is a major reason why mature optimization toolchains remain extremely strong in practice.

Surveys provide a broad picture of how machine learning has entered this landscape, and how CO problems are used as testbeds for learning-based decision-making .

The Traveling Salesperson Problem

The Traveling Salesperson Problem (TSP) is a classical benchmark in combinatorial optimization. The name comes from its canonical story: a salesperson wants to plan a trip that visits a set of cities exactly once and returns home, while minimizing total travel distance.

Formally, given $N$ cities represented by coordinates $x_1,\dots,x_N \in \mathbb{R}^2$, a tour is an ordering in which each city is visited exactly once and the route returns to the start. The symmetric Euclidean TSP asks for the tour of minimum total length, where the cost between two cities is their Euclidean distance (and is symmetric). Writing a tour as a permutation of cities $\pi$, its length is the sum of distances between consecutive cities in that order, including the closing edge back to the first city:

It is often useful to view a TSP instance as a complete weighted graph: each city is a node, and the cost of traveling between cities $i$ and $j$ is an edge weight $d_{ij}$. The animation below shows a random TSP instance. Hover over a city to highlight its distances to the others, and use the slider to control how many edges are displayed. You can also click Random tour to draw a uniformly random tour (a random permutation of the cities), which typically yields a poor solution. In the next section, we will present some strategies to obtain much better solutions.

Classical Algorithms for the TSP

Even for moderate $N$, the search space is enormous: fixing a start city still leaves $(N-1)!$ possible tours ($(N-1)!/2$ in the symmetric TSP, since reversing a tour gives the same length). For example, with $N=20$ this is $19! \approx 1.2\times 10^{17}$ candidate tours. Exhaustively evaluating every tour and selecting the best is therefore computationally infeasible.

There are exact solvers that can find optimal tours by combining relaxations, bounds, and systematic search (e.g., branch-and-cut). But that is not the focus of this blog. Instead, we will look at two classical strategies used to obtain (not optimal but high-quality) tours efficiently: constructive heuristics and local search.

Constructive heuristics

A heuristic is a “strategy or rule” used when finding the optimal solution is computationally impossible. Constructive heuristics build a solution step-by-step by making choices following specific rules.

There are many constructive heuristics for the TSP, here two of the most well known:

• Nearest Neighbor: Starting from a city, repeatedly go to the nearest unvisited city, until all cities are visited, then go back to the initial city.
• Nearest Insertion: Maintain a partial tour and insert the next city where it increases the tour length the least.

The primary drawback of these methods is that they are myopic. Because these algorithms never “look ahead,” they often result in a logarithmic approximation factor. In plain English: as the map gets bigger, the gap between the heuristic’s guess and the actual shortest path grows significantly. They are prone to “the lighthouse effect,” where they travel efficiently for 90% of the trip but are forced to take a massive, inefficient leap at the end to close the loop.

Local search

Once a constructive heuristic provides an initial feasible solution, Local Search (LS) takes over to optimize it. It operates on the principle of neighborhoods: it takes the current route and looks at “neighboring” routes that are only slightly different.

To move in the neighborhood of solutions, we define operators (or actions later). One of the most used operator in the TSP is the 2-opt. The 2-opt selects two non-adjacent edges, (A,B) and (C,D), deletes them, and replaces them with (A,C) and (B,D).

Therefore, the LS takes a solution and test several 2-opt moves, if any of those moves improves the quality of the tour it moves there, and continues repeatedly improving the solution until there is no possible improving 2-opt move in the neighborhood (we reached a local optima).

Demo

In the demo below we show how these two families work in TSP:

Why Neural Combinatorial Optimization

How can we improve over simple heuristics, without paying the computational cost of exact solvers? This is the motivation behind Neural Combinatorial Optimization (NCO). The core idea is to learn strong heuristics from data: rather than simple decision rules, we train a neural network model to make the key choices that a solver repeatedly faces.

To make it concrete, consider a constructive TSP heuristic such as Nearest Neighbor. At each step it applies a fixed rule: “go to the closest unvisited city.” NCO asks: what if, instead, we could query a model: given this instance and the current city, where should I go next? A learned policy can condition on richer context than a single distance comparison, potentially capturing patterns that are hard to encode with simple rules.

This learning perspective is attractive because neural networks have shown a strong ability to learn complex input–output mappings from large datasets. In NCO, we leverage that ability by training on a dataset of problem instances, and then deploying the trained model at inference time to produce solutions for unseen instances.

Neural Combinatorial Optimization Methods

The idea of using neural networks for combinatorial optimization predates modern deep learning: early work explored Hopfield networks for problems like TSP. What changed around 2015 is that new neural architectures and training recipes, together with increased computational power, made it practical to learn decision-making policies that operate on variable-size sets and graphs. In routing, a key step was learning to map sets/graphs → permutations/structures, first with pointer-style decoders and then with attention-based encoder–decoders .

Since then, and imitating the classical optimization algorithms, the space of NCO methods has diversified along two main families:

1. Neural Constructive (NC) models, which produce a solution from scratch.
2. Neural Improvement (NI) models, which, starting from a complete tour, iteratively apply local modifications to it.

A unifying view

Both families can be described by the same template. Let $x$ denote the static instance information (e.g., city coordinates or a distance matrix). Let $s_t$ denote the dynamic state at decision step $t$ (information that changes from step to step). A neural solver is then a policy

where the action $a_t$ is either “pick the next element” (constructive) or “apply a modification” (improvement).

• In constructive TSP, $s_t$ typically includes the set of visited cities and the current partial tour.
• In improvement TSP, $s_t$ is typically a complete tour (and sometimes a short history of recent moves).

This framing makes clear that both are sequence problems, differing mainly in what the action space is and how the dynamic state is represented.

Neural constructive methods

We can distinguish two types of constructive methods: Autoregressive and Non-autoregressive methods.

Autoregressive (AR) construction builds a tour one city at a time:

often implemented with an encoder that embeds the cities and a decoder that attends over remaining (unvisited) nodes.

Non-autoregressive (NAR) construction predicts a global object in one shot, commonly an edge score matrix (a “heatmap”) $H_{ij}$ that indicates how compatible it is to connect cities $i$ and $j$. A separate decoding procedure is then used to turn $H$ into a valid tour. This includes approaches based on graph prediction and diffusion-style generation.

Typical strength. Constructive models are excellent at amortizing: after training, a single run can produce a good solution quickly. Extra compute is often spent on restarts (sampling multiple candidates and keeping the best) rather than deeper reasoning within one construction.

Neural improvement methods

Improvement methods start from a complete tour $\pi^{(0)}$ and apply a sequence of local edits:

This viewpoint connects naturally to “learning to search”: the model is not predicting a tour directly, but learning a strategy for navigating the solution space under a step budget.

Typical strength. Improvement methods naturally define an anytime procedure: you can stop at any step and return the best tour found so far, trading compute for quality in a direct way.

Learning in NCO

After choosing an NCO method, we still need to decide how the model learns. In practice there are three common routes:

• Supervised / imitation learning.
  Train the model to imitate a strong “teacher” (an exact solver, or a good heuristic). This is usually stable and sample-efficient, but producing good labels can be expensive.

• Reinforcement learning.
  Let the model sample its own decisions and learn from feedback derived from the objective: how good is the constructed tour, or how much does a proposed move improve it? RL avoids the need for optimal labels, but it is typically more data-hungry and can be harder to stabilize.

• Unsupervised learning.
  Learn a scoring (energy) function that assigns higher scores (lower energy) to better solutions, and then generate solutions by optimizing or sampling from that score. Many score-based and diffusion-style approaches fit this view, where learning focuses on modeling structure and inference performs the actual search.

Wrapping up

We have now met the main ingredients that motivate Neural Combinatorial Optimization. If there is one takeaway from this introduction, it is that NCO is best viewed as learning solver behavior for a problem family: the model is trained on many instances, and then reused at inference time to make fast, informed choices on unseen instances.

In the next posts, we will go deeper into (i) how different NCO method families spend compute, (ii) how learning signals shape solver behavior, and (iii) how to evaluate these methods fairly under realistic budgets.