[watermarking] Add DFlash support to dual-key gumbel-max watermarking (#59554)

Signed-off-by: Shern Shiou Tan <shernshiou@gmail.com>
Signed-off-by: Simon Veitner <sveitner@redhat.com>
Signed-off-by: Raphael Rialland <raphael.rialland@mistral.ai>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Simon Veitner <sveitner@redhat.com>
Co-authored-by: Raphael Rialland <raphael.rialland@mistral.ai>
Co-authored-by: Lucas Wilkinson <LucasWilkinson@users.noreply.github.com>
This commit is contained in:
Shern Shiou Tan
2026-10-15 22:06:06 +00:00
committed by GitHub
co-authored by Claude Opus 5.5 Simon Veitner Raphael Rialland Lucas Wilkinson
parent e711723352
commit d92a4f25f2
10 changed files with 626 additions and 61 deletions
+22 -8
View File
@@ -3732,34 +3732,48 @@ def test_dual_key_gumbel_requires_probabilistic_drafting():
config._check_supports_watermarking()
@pytest.mark.parametrize("method", ["eagle", "eagle3", "mtp"])
def test_dual_key_gumbel_supports_probabilistic_speculative_decoding(method):
@pytest.mark.parametrize(
("method", "parallel_drafting"),
[
("eagle", False),
("eagle3", False),
("mtp", False),
("dspark", True),
("dflash", True),
],
)
def test_dual_key_gumbel_supports_probabilistic_speculative_decoding(
method, parallel_drafting
):
config = _watermarked_vllm_config()
config.watermark_config = WatermarkConfig(algorithm="dual_key_gumbel", key=42)
config.speculative_config = SimpleNamespace(
method=method,
draft_sample_method="probabilistic",
rejection_sample_method="standard",
parallel_drafting=False,
parallel_drafting=parallel_drafting,
)
config._check_supports_watermarking()
def test_dual_key_gumbel_supports_dspark():
@pytest.mark.parametrize("architecture", ["DFlash2DraftModel", "LiLiCorrDraftModel"])
def test_dual_key_gumbel_rejects_dflash_candidate_drafts(architecture):
config = _watermarked_vllm_config()
config.watermark_config = WatermarkConfig(algorithm="dual_key_gumbel", key=42)
config.speculative_config = SimpleNamespace(
method="dspark",
method="dflash",
draft_sample_method="probabilistic",
rejection_sample_method="standard",
parallel_drafting=True,
draft_model_config=SimpleNamespace(architectures=[architecture]),
)
config._check_supports_watermarking()
with pytest.raises(ValueError, match="candidate-head drafters"):
config._check_supports_watermarking()
def test_dual_key_gumbel_rejects_non_autoregressive_speculation():
def test_dual_key_gumbel_rejects_unsupported_speculative_method():
config = _watermarked_vllm_config()
config.watermark_config = WatermarkConfig(algorithm="dual_key_gumbel", key=42)
config.speculative_config = SimpleNamespace(
@@ -3769,7 +3783,7 @@ def test_dual_key_gumbel_rejects_non_autoregressive_speculation():
parallel_drafting=False,
)
with pytest.raises(ValueError, match="autoregressive model-based"):
with pytest.raises(ValueError, match="Watermarking supports only"):
config._check_supports_watermarking()
+157 -7
View File
@@ -36,6 +36,7 @@ from vllm.v1.worker.gpu.sample.watermark import (
philox_gumbel_sample,
repeated_context_mask,
)
from vllm.v1.worker.gpu.spec_decode.dflash.speculator import DFlashSpeculator
from vllm.v1.worker.gpu.spec_decode.dspark.speculator import DSparkSpeculator
from vllm.v1.worker.gpu.spec_decode.speculator import DraftModelSpeculator
@@ -254,8 +255,8 @@ def test_speculative_decoding_uses_fixed_dual_key_roles():
assert draft is not None
assert draft.watermarker.prf.key == derive_watermark_key(42, b"key_a")
assert draft.num_speculative_steps == 3
assert draft.deduplicate_contexts == "all"
assert draft.deduplicate_contexts_max_history is None
assert draft.state.deduplicate_contexts == "all"
assert draft.state.deduplicate_contexts_max_history is None
def test_recovery_key_rejects_the_unsplit_dual_key_watermarker():
@@ -1324,8 +1325,8 @@ def test_draft_sampler_uses_draft_key_and_advances_context(monkeypatch):
deduplicate_contexts="none",
deduplicate_contexts_max_history=None,
)
draft_watermarker.contexts.copy_(torch.tensor([[1, 2], [3, 4]]))
draft_watermarker.enabled = torch.tensor([True, False])
draft_watermarker.state.contexts.copy_(torch.tensor([[1, 2], [3, 4]]))
draft_watermarker.state.enabled = torch.tensor([True, False])
speculator.draft_watermarker = draft_watermarker
monkeypatch.setattr(
"vllm.v1.watermarking.watermarker.gumbel_sample",
@@ -1343,7 +1344,7 @@ def test_draft_sampler_uses_draft_key_and_advances_context(monkeypatch):
)
assert torch.equal(sampled, torch.tensor([7, 4]))
assert torch.equal(draft_watermarker.contexts, torch.tensor([[2, 7], [4, 4]]))
assert torch.equal(draft_watermarker.state.contexts, torch.tensor([[2, 7], [4, 4]]))
def test_draft_sampler_uses_ordinary_samples_for_repeated_contexts(monkeypatch):
@@ -1602,11 +1603,12 @@ def test_draft_watermarker_deduplicates_across_a_block_on_cuda(
[True, True],
]
assert torch.equal(
draft_watermarker.prior_contexts[:num_reqs].cpu(),
draft_watermarker.state.prior_contexts[:num_reqs].cpu(),
torch.tensor([[[5, 6], [6, 6], [6, 6]], [[6, 3], [3, 6], [6, 6]]]),
)
assert torch.equal(
draft_watermarker.contexts[:num_reqs].cpu(), torch.tensor([[6, 6], [6, 6]])
draft_watermarker.state.contexts[:num_reqs].cpu(),
torch.tensor([[6, 6], [6, 6]]),
)
for step, logits in enumerate(step_logits):
# The 0-d draft step selects the logits cache column.
@@ -1661,6 +1663,154 @@ def test_draft_watermarker_cuda_graph_reads_current_prompt_lens():
assert mask.item()
def test_dflash_draft_sampler_watermarks_drafts_in_step_order(monkeypatch):
class NextTokenWatermarker:
context_width = 2
@staticmethod
def _try_sample_block(*args, **kwargs):
return None
@staticmethod
def sample(logits, contexts, random_sampler=None, skip_mask=None):
watermarked = contexts[:, -1] + 1
return WatermarkSample(
torch.where(skip_mask, random_sampler(logits), watermarked), logits
)
def ordinary_sample(logits, idx_mapping, temperature, seed, pos, **kwargs):
assert kwargs["use_fp64"]
cache, col = kwargs["logits_cache"], kwargs["logits_cache_col"]
cache[idx_mapping, col] = kwargs["logits_cache_source"]
return seed[idx_mapping] + pos
monkeypatch.setattr(
"vllm.v1.watermarking.watermarker.gumbel_sample", ordinary_sample
)
num_reqs, num_steps, vocab_size = 3, 2, 4
draft_watermarker = DraftWatermarker(
NextTokenWatermarker(),
max_num_reqs=8,
device=torch.device("cpu"),
num_speculative_steps=num_steps,
deduplicate_contexts="none",
deduplicate_contexts_max_history=None,
)
# Batch rows hold request slots 2, 0, 1. Slot 0 is greedy and row 2 opted out.
draft_watermarker.state.contexts[:num_reqs] = torch.tensor([[1, 2], [3, 4], [5, 6]])
draft_watermarker.state.enabled[:num_reqs] = torch.tensor([True, True, False])
speculator = object.__new__(DFlashSpeculator)
speculator.model = SimpleNamespace(
compute_logits=lambda hidden_states: hidden_states
)
speculator.draft_watermarker = draft_watermarker
speculator.use_fp64_gumbel = True
speculator.acceptance_estimator = None
batch_slots = torch.tensor([2, 0, 1])
logits = torch.arange(num_reqs * num_steps * vocab_size, dtype=torch.float32)
draft_logits = torch.zeros(num_reqs, num_steps, vocab_size)
sampled = speculator.sample_draft(
hidden_states=logits.view(-1, vocab_size),
sample_src_positions=torch.arange(num_reqs * num_steps),
idx_mapping=batch_slots.repeat_interleave(num_steps),
temperature=torch.tensor([0.0, 1.0, 0.5]),
seeds=torch.tensor([100, 200, 300]),
draft_step=torch.arange(num_steps).repeat(num_reqs),
draft_logits=draft_logits,
num_steps=num_steps,
)
assert torch.equal(sampled, torch.tensor([3, 4, 102, 103, 204, 205]))
assert torch.equal(draft_logits[batch_slots], logits.view(num_reqs, num_steps, -1))
@pytest.mark.skipif(
not current_platform.is_cuda_alike(), reason="requires a CUDA-like accelerator"
)
@pytest.mark.parametrize("dtype", [torch.float32, torch.bfloat16])
@pytest.mark.parametrize("deduplicate_contexts", ["none", "single_turn", "all"])
def test_dflash_draft_sampler_matches_step_loop_on_cuda(deduplicate_contexts, dtype):
"""The fused CUDA `sample_block` is bit-exact with sampling step by step.
Covers repeated contexts, a NaN logit, and greedy, opted-out and padding
rows; padding rows are discarded, so only valid rows are compared.
"""
num_reqs, num_steps, vocab_size, max_num_reqs = 4, 5, 1500, 6
generator = torch.Generator().manual_seed(0)
logits = torch.randn(num_reqs, num_steps, vocab_size, generator=generator) * 3
logits[..., :3] += 6
logits[0, 1, 5] = float("nan")
logits = logits.to(dtype).cuda()
idx_mapping = torch.tensor([4, 2, 0, -1], dtype=torch.int32)
valid = (idx_mapping >= 0).cuda()
idx_mapping = idx_mapping.repeat_interleave(num_steps).cuda()
temperature = torch.tensor([0.7, 1.0, 0.0, 1.3, 0.6, 0.9]).cuda()
seeds = torch.arange(max_num_reqs).cuda() * 1000
pos = (torch.arange(num_steps).repeat(num_reqs) + 20).cuda()
draft_step = torch.arange(num_steps).repeat(num_reqs).cuda()
contexts = torch.randint(0, 3, (num_reqs, 2), generator=generator)
contexts[0, 0] = -1
all_token_ids = torch.randint(0, 3, (max_num_reqs, 32), generator=generator)
def run(fused: bool):
draft_watermarker = DraftWatermarker(
GumbelWatermarker(key=42, context_width=2),
max_num_reqs=max_num_reqs,
device=torch.device("cuda"),
num_speculative_steps=num_steps,
deduplicate_contexts=deduplicate_contexts,
deduplicate_contexts_max_history=None,
)
draft_watermarker.prepare(
contexts=contexts.cuda(),
enabled=torch.tensor([True, False, True, True]).cuda(),
all_token_ids=all_token_ids.cuda(),
prompt_lens=torch.full((max_num_reqs,), 4).cuda(),
total_lens=torch.full((max_num_reqs,), 24).cuda(),
)
draft_logits = torch.zeros(max_num_reqs, num_steps, vocab_size, dtype=dtype)
draft_logits = draft_logits.cuda()
args = (temperature, seeds)
if fused:
sampled = draft_watermarker.sample_block(
logits.view(-1, vocab_size),
idx_mapping,
*args,
pos,
logits_cache=draft_logits,
logits_cache_col=draft_step,
)
else:
by_step = [t.view(num_reqs, num_steps) for t in (idx_mapping, pos)]
steps = draft_step.view(num_reqs, num_steps)
sampled = torch.stack(
[
draft_watermarker.sample(
logits[:, step],
by_step[0][:, step],
*args,
by_step[1][:, step],
logits_cache=draft_logits,
logits_cache_col=steps[:, step],
apply_temperature=True,
is_drafting=True,
)
for step in range(num_steps)
],
dim=1,
).view(-1)
return (
sampled.view(num_reqs, num_steps)[valid],
draft_watermarker.state.contexts[:num_reqs][valid],
draft_watermarker.state.prior_contexts,
draft_logits,
)
for fused, reference in zip(run(fused=True), run(fused=False)):
torch.testing.assert_close(fused, reference, rtol=0, atol=0, equal_nan=True)
def test_dspark_reduced_vocab_draft_sampler_applies_watermarking(monkeypatch):
speculator = object.__new__(DSparkSpeculator)
speculator.draft_logits = torch.zeros(2, 1, 8)