Update app.py

app.py

@@ -12,8 +12,230 @@ token = os.environ['model_fetch']
 
 anonymizer_repo = Repository(local_dir="anonymizer", clone_from="felixrosberg/anonymizer", use_auth_token=token)
 
-from anonymizer.face_anonymizer_image_v5_3dmm_obscured_work import fetch_demo
+from anonymizer.face_anonymizer_image_v5_3dmm_obscured_work import *
 
-anonymizer_demo = fetch_demo()
-anonymizer_demo.queue()
-anonymizer_demo.launch()
+description = "Interactive demo of facial anonymization for images. " \
+              "You can also perform " \
+              "zero-shot face swapping using the anonymizer. **Note** that this model " \
+              "display " \
+              "an interesting behaviour, where it in most cases preserves ethnicity and gender even if source and " \
+              "target differ in these two attributes. You can also play around with *reconstruction attacks*, an adversarial " \
+              "model that can revert the anonymization. Furthermore, you can choose to include adversarial defense " \
+              "noise against the *reconstruction attack* model.\n\n"
+
+article = "## Options \n " \
+          "- **Zero-shot face swap**: Performs face swap using the *name pending* anonymizer. \n" \
+          "- **Reconstruction attack**: After anonymization or face swap, performs a reconstruction attack, " \
+          "retrieving the original identity. \n " \
+          "- **Adverarial Defense**: Applies a uniform noise after anonymization or face swap, before a " \
+          "reconstruction attack, disrupting the reconstruction attack. \n " \
+          "- **Use anchor**: With this option, we generate anchor identities from precalculated identities. If " \
+          "this is not used, the original identity could be easily figured out be searching for a match with " \
+          "-z, where z is an identity embedding in a data base. \n" \
+          "- **3DMM**: Change to model regularized by a 3D Morphable Model. Better pose performance, slightly worse " \
+          "identity performance. As of now, reconstruction attack does not work on this model. \n" \
+          "## Sliders \n " \
+          "- **Defense Strength**: Controls how much adversarial defense noise to add. \n " \
+          "- **Margin**: Controls the cosine distance margin allowed when sampling anonymization identities. \n " \
+          "- **SLERP Factor**: Controls how the anchors are established. Expect variation in the anonymized face " \
+          "when changing this together with the margin. \n" \
+          "- **ID Interpolation**: Controls linear interpolation between target and source identity. \n " \
+          "- **Detection Scale**: Resizes the images with given value before passing the the detector. Useful " \
+          "for image with smaller faces that the detector struggle to detect. Increases inference time if > 1 " \
+          "and vice versa. \n" \
+          "## Outputs \n " \
+          "- **Output**: Manipulated face(s), anonymization, face swap, reconstruction attack etc. \n " \
+          "- **Mask**: The predicted mask from the model or the reconstruction attack model. \n" \
+          "- **Cosine Distances**: The mean cosine distance between anonymized face, target, inverse target, " \
+          "source and reconstruction. Visualizes the identity difference. If there are several faces present, " \
+          "this will demonstrate the mean. \n\n" \
+          "To consider the anonymization a success, we generally want the cosine distance between anonymized and " \
+          "target, anonymized and inverse target, and target and reconstruction to be > 0.63 (the " \
+          "threshold for ArcFace for a false acceptance rate of 0.001). \n \n" \
+          "## Disclaimer: DeepFake Capabilities \n " \
+          "This model is able to do identity swaps that is able to be exceptionally convincing for state-of-the-art facial " \
+          "recognition models. However, when changing the identity, the results are perceptually limited. Meaning that in " \
+          "most cases you are not really to notice the imposed identity. Thus, it is NOT practical for deep faking people in " \
+          "a malicious manner. To summaries, DeepFake capabilities are poor, anonymization capabilities are strong!"
+
+theme = gr.themes.Monochrome(
+    secondary_hue="emerald",
+    neutral_hue="teal",
+).set(
+    body_background_fill='*primary_950',
+    body_background_fill_dark='*secondary_950',
+    body_text_color='*primary_50',
+    body_text_color_dark='*secondary_100',
+    body_text_color_subdued='*primary_300',
+    body_text_color_subdued_dark='*primary_300',
+    background_fill_primary='*primary_600',
+    background_fill_primary_dark='*primary_400',
+    background_fill_secondary='*primary_950',
+    background_fill_secondary_dark='*primary_950',
+    border_color_accent='*secondary_600',
+    border_color_primary='*secondary_50',
+    border_color_primary_dark='*secondary_50',
+    color_accent='*secondary_50',
+    color_accent_soft='*primary_500',
+    color_accent_soft_dark='*primary_500',
+    link_text_color='*secondary_950',
+    link_text_color_dark='*primary_50',
+    link_text_color_active='*primary_50',
+    link_text_color_active_dark='*primary_50',
+    link_text_color_hover='*primary_50',
+    link_text_color_hover_dark='*primary_50',
+    link_text_color_visited='*primary_50',
+    block_background_fill='*primary_950',
+    block_background_fill_dark='*primary_950',
+    block_border_color='*secondary_500',
+    block_border_color_dark='*secondary_500',
+    block_info_text_color='*primary_50',
+    block_info_text_color_dark='*primary_50',
+    block_label_background_fill='*primary_950',
+    block_label_background_fill_dark='*secondary_950',
+    block_label_border_color='*secondary_500',
+    block_label_border_color_dark='*secondary_500',
+    block_label_text_color='*secondary_500',
+    block_label_text_color_dark='*secondary_500',
+    block_title_background_fill='*primary_950',
+    panel_background_fill='*primary_950',
+    panel_border_color='*primary_950',
+    checkbox_background_color='*primary_950',
+    checkbox_background_color_dark='*primary_950',
+    checkbox_background_color_focus='*primary_950',
+    checkbox_border_color='*secondary_500',
+    input_background_fill='*primary_800',
+    input_background_fill_focus='*primary_950',
+    input_background_fill_hover='*secondary_950',
+    input_placeholder_color='*secondary_950',
+    slider_color='*primary_950',
+    slider_color_dark='*primary_950',
+    table_even_background_fill='*primary_800',
+    table_odd_background_fill='*primary_600',
+    button_primary_background_fill='*primary_800',
+    button_primary_background_fill_dark='*primary_800'
+)
+
+random_ch = ['_', '/', '|', '*', '.', '#', '¤', '£', '?', '!', '%', '~', '^', '-', '=', '@', 'o', ']', '[', '§', 'o']
+
+
+def button_change(inputs):
+    if "Reconstruction Attack" in inputs and "Zero-shot Face Swap" in inputs:
+        s_s = ""
+        for s in "Face Swap and Reconstruct":
+            ch_0 = random_ch[np.random.randint(len(random_ch))]
+            ch_1 = random_ch[np.random.randint(len(random_ch))]
+            s_s += s
+            time.sleep(0.01)
+            yield gr.Button(ch_0 + s_s + ch_1), gr.CheckboxGroup(value=inputs, interactive=False)
+        time.sleep(0.01)
+        yield gr.Button(s_s), gr.CheckboxGroup(value=inputs, interactive=True)
+    elif "Reconstruction Attack" in inputs and "Zero-shot Face Swap" not in inputs:
+        s_s = ""
+        for s in "Anonymize and Reconstruct":
+            ch_0 = random_ch[np.random.randint(len(random_ch))]
+            ch_1 = random_ch[np.random.randint(len(random_ch))]
+            s_s += s
+            time.sleep(0.01)
+            yield gr.Button(ch_0 + s_s + ch_1), gr.CheckboxGroup(value=inputs, interactive=False)
+        time.sleep(0.01)
+        yield gr.Button(s_s), gr.CheckboxGroup(value=inputs, interactive=True)
+    elif "Zero-shot Face Swap" in inputs:
+        s_s = ""
+        for s in "Face Swap":
+            ch_0 = random_ch[np.random.randint(len(random_ch))]
+            ch_1 = random_ch[np.random.randint(len(random_ch))]
+            s_s += s
+            time.sleep(0.03)
+            yield gr.Button(ch_0 + s_s + ch_1), gr.CheckboxGroup(value=inputs, interactive=False)
+        time.sleep(0.03)
+        yield gr.Button(s_s), gr.CheckboxGroup(value=inputs, interactive=True)
+    else:
+        s_s = ""
+        for s in "Anonymize":
+            ch_0 = random_ch[np.random.randint(len(random_ch))]
+            ch_1 = random_ch[np.random.randint(len(random_ch))]
+            s_s += s
+            time.sleep(0.03)
+            yield gr.Button(ch_0 + s_s + ch_1), gr.CheckboxGroup(value=inputs, interactive=False)
+        time.sleep(0.03)
+        yield gr.Button(s_s), gr.CheckboxGroup(value=inputs, interactive=True)
+
+
+with gr.Blocks(theme=theme,
+               css=""".gradio-container {background: url('file=anonymizer/assets/background6.gif')}""") as blk_demo:
+    gr.Markdown(value="# Face Anonymizer")
+    with gr.Row():
+        with gr.Column():
+            with gr.Box():
+                trg_in = gr.Image(type="pil", label='Target', height=300)
+                src_in = gr.Image(type="pil", label='Source', height=300)
+                with gr.Row():
+                    b1 = gr.Button("Anonymize")
+                with gr.Row():
+                    with gr.Accordion("Options", open=False):
+                        chk_in = gr.CheckboxGroup(["Zero-shot Face Swap",
+                                                   "Reconstruction Attack",
+                                                   "Adversarial Defense",
+                                                   "Use Anchor",
+                                                   "3DMM"],
+                                                  value=["Use Anchor"],
+                                                  label="Mode",
+                                                  info="Perform zero-shot face swap? "
+                                                       "Apply reconstruction attack? "
+                                                       "Apply defense against reconstruction attack? "
+                                                       "Use anchor identities for fake sampling?")
+                        def_in = gr.Slider(0.0, 0.2, value=0.1,
+                                           label='Defense Strength',
+                                           info="Strength of the defense noise against reconstruction attacks.")
+                        mrg_in = gr.Slider(0.0, 1.0, value=0.3,
+                                           label='Margin',
+                                           info="Margin for sampling fake identities.")
+                        slp_in = gr.Slider(0.0, 1.0, value=0.5,
+                                           label='SLERP Factor',
+                                           info="SLERP disance when establishing anchor identities.")
+                        idi_in = gr.Slider(0.0, 1.0, value=0.0,
+                                           label='ID Interpolation',
+                                           info="Interpolation between target and source id vectors.")
+                        det_in = gr.Slider(0.1, 2.0, value=1.0,
+                                           label='Detection Scale',
+                                           info="Resizes the images before passing to the detector.")
+
+            gr.Examples(examples=[['anonymizer/assets/0.jpg'], ['anonymizer/assets/1.jpg'], ['anonymizer/assets/2.jpg'], ['anonymizer/assets/3.jpg'], ['anonymizer/assets/4.jpg']],
+                        inputs=trg_in)
+        with gr.Column():
+            with gr.Box():
+                ano_out = gr.Image(type="pil", label='Output', height=300, min_width=0)
+                msk_out = gr.Image(type="pil", label='Mask', height=300, min_width=0)
+                with gr.Row():
+                    with gr.Accordion("Cosine Distances", open=False):
+                        plt_out_0 = gr.Slider(0.0, 2.0, value=0.0, label='',
+                                              info="Anonymized and target")
+                        plt_out_1 = gr.Slider(0.0, 2.0, value=0.0, label='',
+                                              info="Anonymized and source")
+                        plt_out_2 = gr.Slider(0.0, 2.0, value=0.0, label='',
+                                              info="Anonymized and -target")
+                        plt_out_3 = gr.Slider(0.0, 2.0, value=0.0, label='',
+                                              info="Target and source")
+                        plt_out_4 = gr.Slider(0.0, 2.0, value=0.0, label='',
+                                              info="Anonymized and reconstructed")
+                        plt_out_5 = gr.Slider(0.0, 2.0, value=0.0, label='',
+                                              info="Target and reconstructed")
+                        cos_info_box = gr.Markdown("Cosine distance between embeddings of target, anonymized, "
+                                                    "reconstruction and source. Note that source is the fake identity "
+                                                    "when using the default anonymization (which will be similar or the same "
+                                                   "depending on if anchor identities are used). Threshold for False Acceptance "
+                                                    "Rate (FAR) of 0.001 is 0.63. If you anonymize using no anchors, you can expect facial "
+                                                    "recognition will find the true identity by searching for -target.")
+                with gr.Row():
+                    with gr.Accordion("Information", open=False):
+                        with gr.Box():
+                            info_box = gr.Markdown(description + article)
+
+    b1.click(inference, inputs=[trg_in, src_in, chk_in, def_in, mrg_in, slp_in, idi_in, det_in],
+             outputs=[ano_out, msk_out, plt_out_0, plt_out_1, plt_out_2, plt_out_3, plt_out_4, plt_out_5])
+    chk_in.change(button_change, inputs=[chk_in], outputs=[b1, chk_in], queue=True)
+
+
+blk_demo.queue()
+blk_demo.launch()