[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:
co-authored by
Claude Opus 5.5
Simon Veitner
Raphael Rialland
Lucas Wilkinson
parent
e711723352
commit
d92a4f25f2
+22
-8
@@ -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()
|
||||
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
Reference in New Issue
Block a user