Docs for the Space

app.py

@@ -145,7 +145,7 @@ with gr.Blocks() as demo:
     detectors, and the [SynthID Text documentaiton][raitk-synthid] for more on
     how this technology works.
 
-    ## Getting started
+    ## Applying a watermark
 
     Practically speaking, SynthID Text is a logits processor, applied to your
     model's generation pipeline after [Top-K and Top-P][cloud-parameter-values],
@@ -169,10 +169,13 @@ with gr.Blocks() as demo:
     `.generate()`, as shown in the snippet below.
 
     ```python
-    from transformers import AutoModelForCausalLM, AutoTokenizer
-    from transformers.generation import SynthIDTextWatermarkingConfig
+    from transformers import (
+        AutoModelForCausalLM,
+        AutoTokenizer,
+        SynthIDTextWatermarkingConfig,
+    )
 
-    # Standard model and toeknizer initialization
+    # Standard model and tokenizer initialization
     tokenizer = AutoTokenizer.from_pretrained('repo/id')
     model = AutoModelForCausalLM.from_pretrained('repo/id')
 
@@ -189,13 +192,20 @@ with gr.Blocks() as demo:
     watermarked_text = tokenizer.batch_decode(output_sequences)
     ```
 
-    Enter up to three prompts then click the generate button. After you click,
-    [Gemma 2B][gemma] will generate a watermarked and non-watermarked repsonses
-    for each non-empty prompt.
+    ## Try it yourself.
+
+    Lets use [Gemma 2B IT][gemma] to help you understand how watermarking works.
+
+    Using the text boxes below enter up to three prompts then click the generate
+    button. Some examples are provided to help get you started, but they are
+    fully editable.
+
+    Gemma will then generate watermarked and non-watermarked repsonses for each
+    non-empty prompt you provided.
 
     [cloud-parameter-values]: https://cloud.google.com/vertex-ai/generative-ai/docs/learn/prompts/adjust-parameter-values
     [gemma]: https://huggingface.co/google/gemma-2b
-    [raitk-synthid]: /responsible/docs/safeguards/synthid
+    [raitk-synthid]: https://ai.google.dev/responsible/docs/safeguards/synthid-text
     [synthid]: https://deepmind.google/technologies/synthid/
     [synthid-hf-config]: https://github.com/huggingface/transformers/blob/v4.46.0/src/transformers/generation/configuration_utils.py
     [synthid-hf-detector]: https://github.com/huggingface/transformers/blob/v4.46.0/src/transformers/generation/watermarking.py
@@ -213,7 +223,21 @@ with gr.Blocks() as demo:
   with gr.Column(visible=False) as generations_col:
     gr.Markdown(
       '''
-      # SynthID: Tool
+      ## Human recognition of watermarked text
+
+      The primary goal of SynthID Text is to apply a watermark to generated text
+      wihtout affecting generation quality. Another way to think about this is
+      that generated text that carries a watermark should be imperceptible to
+      you, the reader, but easily perceived by a watermark detector.
+
+      The responses from Gemma are shown below. Use the checkboxes to mark which
+      responses you think are the watermarked, then click the "reveal" button to
+      see the true values.
+
+      The [research paper][synthid-nature] has an in-depth study examining human
+      perception of watermared versus non-watermarked text.
+
+      [synthid-nature]: https://www.nature.com/articles/s41586-024-08025-4
       '''
     )
     generations_grp = gr.CheckboxGroup(
@@ -225,7 +249,23 @@ with gr.Blocks() as demo:
   with gr.Column(visible=False) as detections_col:
     gr.Markdown(
       '''
-      # SynthID: Tool
+      ## Detecting watermarked text
+
+      The only way to properly detect watermarked text is with a trained
+      classifier. This Space uses a pre-trained classifier hosted on Huggin Face
+      Hub. For production uses you will need to train your own classifiers to
+      recognize your watermarks. A [Bayesian detector][synthid-hf-detector] is
+      provided in Transformers, along with an
+      [end-to-end example][synthid-hf-detector-e2e] of how to train one of these
+      detectors.
+
+      You can see how your guesses compared to the actaul results below. As
+      above, the responses are displayed in checkboxes. If the box is checked,
+      then the text carries a watermark. Your correct guesses are annotated with
+      the "Correct" prefix.
+
+      [synthid-hf-detector]: https://github.com/huggingface/transformers/blob/v4.46.0/src/transformers/generation/watermarking.py
+      [synthid-hf-detector-e2e]: https://github.com/huggingface/transformers/blob/v4.46.0/examples/research_projects/synthid_text/detector_bayesian.py
       '''
     )
     revealed_grp = gr.CheckboxGroup(
@@ -235,7 +275,26 @@ with gr.Blocks() as demo:
             'marked as correct or incorrect in the text.'
         ),
     )
-    detect_btn = gr.Button('Detect', visible=False)
+    gr.Markdown(
+      '''
+      ## Limitations
+
+      SynthID Text watermarks are robust to some transformations, such as
+      cropping pieces of text, modifying a few words, or mild paraphrasing, but
+      this method does have limitations.
+
+      - Watermark application is less effective on factual responses, as there
+        is less opportunity to augment generation without decreasing accuracy.
+      - Detector confidence scores can be greatly reduced when an AI-generated
+        text is thoroughly rewritten, or translated to another language.
+
+      SynthID Text is not built to directly stop motivated adversaries from
+      causing harm. However, it can make it harder to use AI-generated content
+      for malicious purposes, and it can be combined with other approaches to
+      give better coverage across content types and platforms.
+      '''
+    )
+    reset_btn = gr.Button('Reset', visible=False)
 
   def generate(*prompts):
     standard, standard_detector = generate_outputs(prompts=prompts)
@@ -295,7 +354,7 @@ with gr.Blocks() as demo:
         reveal_btn: gr.Button(visible=False),
         detections_col: gr.Column(visible=True),
         revealed_grp: gr.CheckboxGroup(choices=choices, value=value),
-        detect_btn: gr.Button(visible=True),
+        reset_btn: gr.Button(visible=True),
     }
 
   reveal_btn.click(
@@ -305,7 +364,28 @@ with gr.Blocks() as demo:
         reveal_btn,
         detections_col,
         revealed_grp,
-        detect_btn
+        reset_btn
+    ],
+  )
+
+  def reset():
+    return {
+        generations_col: gr.Column(visible=False),
+        detections_col: gr.Column(visible=False),
+        revealed_grp: gr.CheckboxGroup(visible=False),
+        reset_btn: gr.Button(visible=False),
+        generate_btn: gr.Button(visible=True),
+    }
+
+  reset_btn.click(
+    reset,
+    inputs=[],
+    outputs=[
+        generations_col,
+        detections_col,
+        revealed_grp,
+        reset_btn,
+        generate_btn,
     ],
   )
 

requirements.txt

@@ -1,6 +1,6 @@
 gradio
 spaces
-transformers>=4.46.0
+transformers @ git+https://github.com/sumedhghaisas2/transformers_private
 
 --extra-index-url https://download.pytorch.org/whl/cu113
 torch