SelectCopy: Controlled Copying in Deep Models

• SelectCopy is a family of mechanisms that selectively copy existing content or generate new output under structural, probabilistic, or semantic constraints.
• It is applied in areas such as sequence-to-sequence learning, image captioning, secure object cloning, and document extraction, ensuring precise structural alignment.
• Empirical studies show that selective copying can improve accuracy and reduce computational overhead by preserving source alignment and controlled reuse.

Searching arXiv for the core paper and adjacent copying-mechanism work to ground the article in current arXiv metadata. {"query":"(Gu et al., 2016) CopyNet copying mechanism sequence-to-sequence learning", "max_results": 5} “SelectCopy” (Editor’s term) denotes a family of computational mechanisms that arbitrate between copying an existing structure and producing an output by generation, transformation, inference, or recomputation. In neural sequence modeling, the copied unit is typically a token or span from an input sequence; in vision it may be an object label, an image region, a text-placement box, or a block of intermediate features; in data fusion it is a shared value that signals source dependence; in software security it is the reachable object graph allowed to remain shared after cloning; and in quantum algorithms it is a table entry coherently loaded into a register. The common technical problem is not copying alone, but controlled copying under structural, probabilistic, or semantic constraints (Gu et al., 2016, Portenier et al., 2019, Verelst et al., 2021, Jensen et al., 2012, Motlagh et al., 19 May 2026).

1. Scope and recurring decision structure

Across the literature, selective copying is defined by three recurrent questions: what may be copied, when copying should dominate over generation or fresh computation, and how copied content interacts with a broader model state. In CopyNet, the alternatives are generation from a fixed vocabulary and copying from source positions under a single shared softmax normalizer; in span-copy editing, the alternatives are single-token generation and whole-span copy actions; in image captioning for novel objects, the alternatives are standard language-model emission and copying object names supplied by external visual classifiers (Gu et al., 2016, Panthaplackel et al., 2020, Yao et al., 2017).

Outside text generation, the same structure reappears with different objects. Copyspace detection treats text placement on images as selecting rectangular regions that satisfy compositional and legibility constraints rather than generating text itself. Context-aware copy-paste selects source content and target placements by caption-based semantic matching, object detection, mask extraction, and compositing constraints. BlockCopy selects spatial blocks to recompute and copies cached features elsewhere. Enterprise document extraction treats repetitive, template-based documents as a “copy-heavy” regime in which structure-aware routing minimizes generative decoding. Deep-Web truth finding treats a shared rare false value as evidence that one source copied another (Lundin et al., 2020, Guo, 2024, Verelst et al., 2021, Wang et al., 11 Oct 2025, Li et al., 2015).

A plausible implication is that selective copying is best understood as an arbitration layer between reuse and reconstruction. The arbitration variable may be explicit, as in pointer-generator gates or reinforcement-trained execution policies, or implicit, as in CopyNet’s shared-normalizer competition and QROM’s circuit-level replacement of “SelectSwap” by “SelectCopy” (Choi et al., 2021, Gu et al., 2016, Motlagh et al., 19 May 2026).

2. CopyNet and token-level copying in sequence-to-sequence learning

The canonical neural formulation is CopyNet, which augments the standard attention-based encoder–decoder architecture with an explicit copying pathway. Given input sequence $x=(x_1,\dots,x_n)$ and output sequence $y=(y_1,\dots,y_m)$, a bidirectional RNN encoder produces hidden states $\mathbf{h}_i$, and an RNN decoder with state $\mathbf{s}_t$ attends to the encoder to compute $\mathbf{c}_t$. At step $t$, the decoder scores two competing emission modes: generation over a fixed vocabulary $V\cup\{\text{unk}\}$ and copying over source positions $1,\dots,n$. The key design is a single shared partition function $Z_t$ across both modes, so the selector is implicit rather than an explicit sigmoid gate (Gu et al., 2016).

For candidate token $y$, the emission probability is

$y=(y_1,\dots,y_m)$0

Because probability mass for duplicate source symbols is summed over positions, collisions are handled automatically: if a token is both in the fixed vocabulary and in the source, both terms contribute. The emergent mode probabilities $y=(y_1,\dots,y_m)$1 and $y=(y_1,\dots,y_m)$2 are the normalized masses of the two groups and satisfy $y=(y_1,\dots,y_m)$3 (Gu et al., 2016).

A distinctive feature is the selective read $y=(y_1,\dots,y_m)$4, which feeds the decoder not only the embedding of the previously emitted token but also a position-weighted summary of source locations where that token occurred. The decoder update uses

$y=(y_1,\dots,y_m)$5

This mechanism does not explicitly score spans, but it biases the state toward copying contiguous subsequences: after copying from location $y=(y_1,\dots,y_m)$6, the next step is biased toward $y=(y_1,\dots,y_m)$7. The model therefore combines semantically driven attention $y=(y_1,\dots,y_m)$8 with location-aware selective read $y=(y_1,\dots,y_m)$9, permitting both multi-token contiguous copying and jumps to new source regions (Gu et al., 2016).

CopyNet is trained end-to-end by maximum likelihood over the mixture distribution,

$\mathbf{h}_i$0

with no supervision for which mode to use. Because copy-mode operates over source symbols, the model can emit OOV or rare words whenever they appear in the input, while generate-mode falls back to $\mathbf{h}_i$1 for true OOVs. In the reported experiments, CopyNet achieved 93.7–98.3% exact-match accuracy on synthetic transformation rules requiring copying $\mathbf{h}_i$2 or $\mathbf{h}_i$3, improved Chinese short-text summarization on LCSTS from approximately $\mathbf{h}_i$4 to approximately $\mathbf{h}_i$5 in ROUGE-1/2/L for word-based modeling, and raised dialogue accuracy on DS-II from $\mathbf{h}_i$6 to $\mathbf{h}_i$7 for Top-1/Top-10. The paper also notes two limitations: the mechanism copies surface forms and is therefore not directly applicable to cross-lingual tasks without modification, and it does not include ablations isolating the selective read from the shared-normalizer mixing (Gu et al., 2016).

3. Supervised gates, span actions, and novel-object captioning

Later work refined token-level copying in two directions: by supervising the copy/generate decision and by enlarging the copied unit from a token to a span. In the enhanced supervised-copy method, a Transformer encoder plus LSTM decoder pointer-generator model retains the standard mixture

$\mathbf{h}_i$8

but adds explicit supervision to both attention and the gate. The timestep loss is

$\mathbf{h}_i$9

where $\mathbf{s}_t$0 for copy-candidates and $\mathbf{s}_t$1 is defined either by Force-copy or by Force-copy-unk. Force-copy drives $\mathbf{s}_t$2 low whenever the gold token appears in the source; Force-copy-unk does so only when the token is both in the source and OOV with respect to the target vocabulary. On CNN/DailyMail, Force-copy-unk reached ROUGE-1/2/L of $\mathbf{s}_t$3 versus $\mathbf{s}_t$4 for the re-implemented PGNet baseline, increased copy precision from $\mathbf{s}_t$5 to $\mathbf{s}_t$6, and raised novel $\mathbf{s}_t$7-gram rates from $\mathbf{s}_t$8 to $\mathbf{s}_t$9. On RotoWire, FCU achieved RG precision $\mathbf{c}_t$0 with $\mathbf{c}_t$1 unique extracted relations. The paper also reports that Force-copy tends to over-copy, whereas Force-copy-unk uses vocabulary size as a control knob over copy versus abstractness (Choi et al., 2021).

A more radical extension is to make the action space itself span-aware. “Copy that! Editing Sequences by Copying Spans” introduces generate actions $\mathbf{c}_t$2 and copy-span actions $\mathbf{c}_t$3 that emit the contiguous subsequence $\mathbf{c}_t$4 in one step. Because many action sequences can produce the same output, training marginalizes over all valid derivations with a backward dynamic program:

$\mathbf{c}_t$5

Span scores are computed from boundary encoder representations via

$\mathbf{c}_t$6

This formulation reduces the number of decisions on edit-heavy tasks where most of the input is unchanged. Reported gains include WikiAtomicEdits accuracy $\mathbf{c}_t$7 versus $\mathbf{c}_t$8 for a token-copy baseline, GitHubEdits $\mathbf{c}_t$9 versus $t$0, C# Fixers one-shot $t$1 versus $t$2, and code-repair accuracy $t$3 versus $t$4 on BFP-small (Panthaplackel et al., 2020).

Image captioning for novel objects instantiates a related but multimodal variant. LSTM-C combines a standard LSTM LLM with a copying distribution over an external object lexicon $t$5, using detector or classifier confidences $t$6 in the copy logits

$t$7

The final probability over $t$8 mixes generation and copying with a fixed scalar $t$9, set to $V\cup\{\text{unk}\}$0 in most experiments. Unlike pointer-generator networks, there is no dynamic $V\cup\{\text{unk}\}$1; copy selection arises from the relative logits and the fixed trade-off. On held-out MSCOCO, LSTM-C with One-hot+GloVe achieved METEOR $V\cup\{\text{unk}\}$2 and average F1 $V\cup\{\text{unk}\}$3, compared with METEOR $V\cup\{\text{unk}\}$4 and F1 $V\cup\{\text{unk}\}$5 for NOC. On ImageNet with external text from BNC+Wikipedia, it reached Novel $V\cup\{\text{unk}\}$6, F1 $V\cup\{\text{unk}\}$7, and Accuracy $V\cup\{\text{unk}\}$8, outperforming NOC’s $V\cup\{\text{unk}\}$9, $1,\dots,n$0, and $1,\dots,n$1 (Yao et al., 2017).

4. Image layout, copy-paste, and compositing

In vision, selective copying often concerns where content should be placed and how copied content should be harmonized. Copyspace detection formulates the placement of text over an image as an object-detection problem over expert-labeled rectangular regions. The dataset contains 20,000 license-free Unsplash images labeled by a team of experts and stratified into four difficulty classes. The paper evaluates YOLOv4, YOLOv5 variants, and Faster R-CNN using mAP@0.5, [email protected]:0.95, and average IoU. YOLOv5x at $1,\dots,n$2 reached [email protected] $1,\dots,n$3, [email protected]:0.95 $1,\dots,n$4, and IoU $1,\dots,n$5; YOLOv5s reached $1,\dots,n$6; Faster R-CNN reached $1,\dots,n$7. Performance degrades sharply with complexity: for YOLOv5x, [email protected] falls from $1,\dots,n$8 in Class 1 to $1,\dots,n$9 in Class 4. The paper explicitly cautions that “good predictions are sometimes disjoint from annotations,” so IoU and mAP undercount aesthetically valid placements (Lundin et al., 2020).

Context-aware image augmentation addresses a different problem: selecting semantically compatible source content and pasting it into a target image without manual annotation. The CACP pipeline uses BLIP to caption a source image, BERT cosine similarity to rank category names, YOLO-365 to localize candidate objects in gallery images, Grad-CAM to derive point prompts, and SAM to extract masks. The paper reports that Grad-CAM-assisted prompts improve mask quality from bbox $Z_t$0 to $Z_t$1 with one CAM point and to $Z_t$2 with three CAM points. On downstream tasks, CACP outperforms random copy-paste and standard augmentation: on Cats vs Dogs, accuracy rises to $Z_t$3 with CACP and $Z_t$4 with CACP+aug; on CamVid, mIoU rises to $Z_t$5 and $Z_t$6; on CityPersons detection, [email protected] rises to $Z_t$7 and $Z_t$8. The reported GPU cost per image pair is approximately $Z_t$9 ms for BLIP, $y$0 ms for YOLO, and $y$1 ms for SAM, for a total of approximately $y$2 ms (Guo, 2024).

“Smart, Deep Copy-Paste” treats harmonization itself as the central copying problem. It receives a source image $y$3, a target image $y$4, and mask $y$5, forms the naive composite

$y$6

and predicts a residual $y$7 so that the final result is

$y$8

Training is self-supervised: from a single image $y$9, the method constructs transformed source content using a geometric homography $y=(y_1,\dots,y_m)$00 and a locally varying photometric transform $y=(y_1,\dots,y_m)$01, then reconstructs the original image with an $y=(y_1,\dots,y_m)$02 loss plus conditional WGAN-GP. The reported hyperparameters are $y=(y_1,\dots,y_m)$03 and $y=(y_1,\dots,y_m)$04 in the total objective, with ADAM $y=(y_1,\dots,y_m)$05, $y=(y_1,\dots,y_m)$06, learning rate $y=(y_1,\dots,y_m)$07, batch size $y=(y_1,\dots,y_m)$08, and $y=(y_1,\dots,y_m)$09k iterations. The method is demonstrated on $y=(y_1,\dots,y_m)$10k face images at $y=(y_1,\dots,y_m)$11 and on Cityscapes, and the paper attributes its behavior to learning to correct shading and moderate geometric inconsistency rather than to explicit flow or homography prediction (Portenier et al., 2019).

5. Spatially selective computation and copy-heavy document extraction

Selective copying can also reduce computation by copying intermediate representations rather than output symbols. BlockCopy partitions feature maps into spatial blocks and trains a lightweight policy network to decide, for each block and frame, whether to execute or copy. For selected blocks, block-sparse convolutions with halo padding recompute features; for non-selected blocks, the previous frame’s features are reused directly. The policy observes the current frame $y=(y_1,\dots,y_m)$12, previous frame state $y=(y_1,\dots,y_m)$13, previous output $y=(y_1,\dots,y_m)$14, and previous execution grid $y=(y_1,\dots,y_m)$15, and is trained online with REINFORCE using a reward

$y=(y_1,\dots,y_m)$16

with $y=(y_1,\dots,y_m)$17 and momentum $y=(y_1,\dots,y_m)$18 in the smoothed cost term. On CityPersons with CSP and target $y=(y_1,\dots,y_m)$19, GMACS drop from $y=(y_1,\dots,y_m)$20 to $y=(y_1,\dots,y_m)$21, runtime from $y=(y_1,\dots,y_m)$22 s/frame to $y=(y_1,\dots,y_m)$23 s/frame, and miss rate on the Reasonable split changes from $y=(y_1,\dots,y_m)$24 to $y=(y_1,\dots,y_m)$25. For Mask R-CNN on Cityscapes, BlockCopy with $y=(y_1,\dots,y_m)$26 roughly halves FLOPs, increases FPS from $y=(y_1,\dots,y_m)$27 to $y=(y_1,\dots,y_m)$28, and drops validation AP by about $y=(y_1,\dots,y_m)$29 (Verelst et al., 2021).

Enterprise-scale document extraction reframes “copy-heavy” as a structure-aware routing problem over repetitive documents. The hybrid OCR–LLM framework evaluates direct, replacement, and table-based extraction over PNG, DOCX, XLSX, and PDF using PaddleOCR, EasyOCR, Docling, MinerU, MarkItDown, Qwen2.5-7B, and Qwen2.5-VL-7B. Table-based extraction minimizes generation by having the LLM emit only structure metadata such as header-to-column mappings and row ranges, after which a deterministic parser extracts contents. On structured documents, table-based methods reach F1 $y=(y_1,\dots,y_m)$30 with $y=(y_1,\dots,y_m)$31 s average latency; on PNG images with PaddleOCR table-based extraction, F1 is $y=(y_1,\dots,y_m)$32 at approximately $y=(y_1,\dots,y_m)$33 s; the multimodal PNG baseline reaches F1 $y=(y_1,\dots,y_m)$34 but requires approximately $y=(y_1,\dots,y_m)$35 s; Docling-based PDF table extraction reaches F1 $y=(y_1,\dots,y_m)$36 at approximately $y=(y_1,\dots,y_m)$37 s; EasyOCR table extraction on PNG and MinerU replacement on PDF both yield F1 $y=(y_1,\dots,y_m)$38. The framework’s central claim is that repetitive structure permits “copy-first” extraction with minimal LLM decoding (Wang et al., 11 Oct 2025).

A shared principle emerges across BlockCopy and enterprise extraction: copying is operationally useful when the system can preserve alignment. BlockCopy preserves alignment through cached block coordinates and halo padding; table-based document extraction preserves alignment through row and column structure. A plausible implication is that selective copying remains stable when geometry or schema is explicit, and degrades when those coordinates are lost, as in OCR outputs that fail to preserve spatial structure (Verelst et al., 2021, Wang et al., 11 Oct 2025).

6. Source dependence, secure cloning, retrieval arbitration, and QROM

In structured data fusion, copying becomes a latent dependency relation among sources. “Scaling up Copy Detection” assumes single truth per item, $y=(y_1,\dots,y_m)$39 false values per item, item independence, copy selectivity $y=(y_1,\dots,y_m)$40, and prior copying probability $y=(y_1,\dots,y_m)$41 with $y=(y_1,\dots,y_m)$42. For two sources $y=(y_1,\dots,y_m)$43 and observations $y=(y_1,\dots,y_m)$44, the posterior probability of independence is

$y=(y_1,\dots,y_m)$45

Shared rare false values contribute strongly positive evidence for copying, while differing values contribute the constant negative term $y=(y_1,\dots,y_m)$46. The scalability contribution is an inverted index over shared values $y=(y_1,\dots,y_m)$47, processed in decreasing order of their contribution upper bound $y=(y_1,\dots,y_m)$48, with pruning, early termination, incremental updates, and optional sampling. The reported speedup is two to three orders of magnitude over naive pairwise copy detection, while truth-finding quality remains essentially unchanged and copy-detection precision/recall stays high, with examples including precision at least $y=(y_1,\dots,y_m)$49 and recall at least $y=(y_1,\dots,y_m)$50 (Li et al., 2015).

In secure object-oriented programming, copying is constrained by policy rather than by probability. “Secure the Clones” introduces type-based annotations such as @Shallow, @Deep, and @Copy(X) to specify the maximally allowed sharing between an object and its clone. The semantics require that any location reachable from the result by following only deep-annotated fields be disjoint from any value reachable from pre-existing caller variables. The analysis uses graph-shaped types $y=(y_1,\dots,y_m)$51 with strong and weak nodes, proves monotonicity of stronger policies, and establishes soundness in Coq: if a program is well typed, all declared copy methods satisfy their copy policies. The paper also notes a limitation: subclasses may add new fields not constrained by the superclass policy, motivating possible “deep-all-except” extensions (Jensen et al., 2012).

Retrieval-augmented generation exposes another arbitration problem: whether a LLM should copy from the prompt context or recall from parametric memory. “To Copy or Not to Copy” constructs an arbitration vector $y=(y_1,\dots,y_m)$52 as the residual-stream centroid difference between irrelevant contexts that elicit recall and relevant-but-false contexts that elicit copying. Intervening with

$y=(y_1,\dots,y_m)$53

steers behavior in two directions. Copy$y=(y_1,\dots,y_m)$54Recall uses $y=(y_1,\dots,y_m)$55 at early-to-middle layers and succeeds only when injected at counterfactual object tokens; Recall$y=(y_1,\dots,y_m)$56Copy uses $y=(y_1,\dots,y_m)$57 at middle-to-late layers and succeeds from object, subject, or last-token locations. On PopQA, Copy$y=(y_1,\dots,y_m)$58Recall recovers to $y=(y_1,\dots,y_m)$59 EM for Gemma2-2B and $y=(y_1,\dots,y_m)$60 for T5Gemma-2B, while Recall$y=(y_1,\dots,y_m)$61Copy raises copying EM to $y=(y_1,\dots,y_m)$62 and $y=(y_1,\dots,y_m)$63; similar asymmetries appear on PEQ. The mechanistic conclusion is that inducing copying is an easier “reactivation” process than restoring recall, which behaves as a fragile suppression process (Farahani et al., 17 Jan 2026).

At the hardware level, selective copying becomes a circuit optimization. “Halving the cost of QROM” replaces the dirty-ancilla SelectSwap architecture with SelectCopy. For a table of $y=(y_1,\dots,y_m)$64 entries, entry width $y=(y_1,\dots,y_m)$65, and bucket parameter $y=(y_1,\dots,y_m)$66, the dirty-ancilla SelectSwap cost is

$y=(y_1,\dots,y_m)$67

whereas SelectCopy reduces this to

$y=(y_1,\dots,y_m)$68

A further bit-packet construction yields

$y=(y_1,\dots,y_m)$69

interpolating the leading prefactor on $y=(y_1,\dots,y_m)$70 from $y=(y_1,\dots,y_m)$71 down to $y=(y_1,\dots,y_m)$72. For $y=(y_1,\dots,y_m)$73 and regimes where $y=(y_1,\dots,y_m)$74, the paper reports an effective reduction of approximately $y=(y_1,\dots,y_m)$75 in the dominant term, matching clean-qubit QROM performance with dirty qubits for practical values of $y=(y_1,\dots,y_m)$76 (Motlagh et al., 19 May 2026).

7. Evaluation, trade-offs, and unresolved questions

A persistent issue across selective-copy systems is that standard metrics often observe only one aspect of correctness. Copyspace detection uses mAP and IoU even though many valid placements may be disjoint from the annotation. CopyNet shows strong empirical results but does not isolate the contributions of selective read and shared-normalizer mixing. Force-copy improves factual extraction but can reduce abstractness, whereas Force-copy-unk improves ROUGE and novel $y=(y_1,\dots,y_m)$77-grams but depends on vocabulary size. RAG arbitration succeeds at moderate scaling but large $y=(y_1,\dots,y_m)$78 values spike perplexity and degrade fluency (Lundin et al., 2020, Gu et al., 2016, Choi et al., 2021, Farahani et al., 17 Jan 2026).

Another recurrent limitation is that copying usually preserves surface form rather than semantic equivalence. CopyNet copies source tokens verbatim and is therefore not directly suited to cross-lingual translation without modification. LSTM-C copies detector labels as single tokens and does not explicitly handle singular/plural variation or multi-word object names. Context-aware copy-paste can fail under domain shift, thin structures, or missed detections. Enterprise document extraction depends critically on structure preservation by OCR or parsers, with catastrophic failures when that assumption breaks. Secure object cloning currently constrains only the fields named in a policy, not arbitrary future fields introduced by subclasses (Gu et al., 2016, Yao et al., 2017, Guo, 2024, Wang et al., 11 Oct 2025, Jensen et al., 2012).

These results suggest that selective copying is most effective when the copied unit has an explicit address: a source position, a span boundary pair, a detected object label, a table cell, a block coordinate, a policy-annotated field, or a bucketed QROM address. When alignment is explicit, copying reduces uncertainty, compute, or latency; when alignment is weak, the system must reintroduce semantics through attention, gating, constraints, or expert annotation. That pattern links CopyNet’s selective read, span-copy marginalization, BlockCopy’s execution masks, enterprise table extraction, Deep-Web copy evidence, and QROM SelectCopy into a single computational theme: copying is a structured decision, not merely a retrieval primitive (Panthaplackel et al., 2020, Verelst et al., 2021, Li et al., 2015, Motlagh et al., 19 May 2026).