First commit.

Signed-off-by: Kieran Fraser <Kieran.Fraser@ibm.com>

.gitignore

@@ -0,0 +1,260 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+!.vscode/*.code-snippets
+!.vscode/extensions.json
+!.vscode/launch.json
+!.vscode/settings.json
+!.vscode/tasks.json
+*$py.class
+*.code-workspace
+*.cover
+*.egg
+*.egg-info/
+*.iws
+*.log
+*.manifest
+*.mo
+*.pot
+*.py,cover
+*.py[cod]
+*.sage.py
+*.so
+*.spec
+*.vsix
+.Python
+.cache
+.coverage
+.coverage.*
+.dmypy.json
+.eggs/
+.env
+.history
+.history/
+.hypothesis/
+.idea/$CACHE_FILE$
+.idea/**/aws.xml
+.idea/**/azureSettings.xml
+.idea/**/contentModel.xml
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/dataSources/
+.idea/**/dbnavigator.xml
+.idea/**/dictionaries
+.idea/**/dynamic.xml
+.idea/**/gradle.xml
+.idea/**/libraries
+.idea/**/markdown-navigator-enh.xml
+.idea/**/markdown-navigator.xml
+.idea/**/markdown-navigator/
+.idea/**/mongoSettings.xml
+.idea/**/shelf
+.idea/**/sonarIssues.xml
+.idea/**/sonarlint/
+.idea/**/sqlDataSources.xml
+.idea/**/tasks.xml
+.idea/**/uiDesigner.xml
+.idea/**/usage.statistics.xml
+.idea/**/workspace.xml
+.idea/caches/build_file_checksums.ser
+.idea/codestream.xml
+.idea/httpRequests
+.idea/replstate.xml
+.idea/sonarlint/
+.idea_modules/
+.installed.cfg
+.ionide
+.ipynb_checkpoints
+.mypy_cache/
+.nox/
+.pdm.toml
+.pybuilder/
+.pyre/
+.pytest_cache/
+.pytype/
+.ropeproject
+.scrapy
+.spyderproject
+.spyproject
+.tox/
+.venv
+.vscode/*
+.vscode/*.code-snippets
+.webassets-cache
+/site
+ENV/
+MANIFEST
+__pycache__/
+__pypackages__/
+atlassian-ide-plugin.xml
+build/
+celerybeat-schedule
+celerybeat.pid
+cmake-build-*/
+com_crashlytics_export_strings.xml
+cover/
+coverage.xml
+crashlytics-build.properties
+crashlytics.properties
+cython_debug/
+db.sqlite3
+db.sqlite3-journal
+develop-eggs/
+dist/
+dmypy.json
+docs/_build/
+downloads/
+eggs/
+env.bak/
+env/
+fabric.properties
+htmlcov/
+instance/
+ipython_config.py
+lib/
+lib64/
+local_settings.py
+nosetests.xml
+out/
+parts/
+pip-delete-this-directory.txt
+pip-log.txt
+profile_default/
+sdist/
+share/python-wheels/
+target/
+var/
+venv.bak/
+venv/
+wheels/
+Pipfile
+.vscode
+Pipfile.lock
+Data - DELETE AT THE END OF THE PROJECT

app.py

@@ -0,0 +1,430 @@
+'''
+ART-JATIC Gradio Example App
+
+To run: 
+- clone the repository
+- execute: gradio examples/gradio_app.py or python examples/gradio_app.py
+- navigate to local URL e.g. http://127.0.0.1:7860
+'''
+
+import torch
+import numpy as np
+import pandas as pd
+from carbon_theme import Carbon
+
+import gradio as gr
+import os
+import matplotlib.pyplot as plt
+
+css = """
+.input-image { margin: auto !important }
+.plot-padding { padding: 20px; }
+"""
+
+def extract_predictions(predictions_, conf_thresh):
+    coco_labels = ['person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light',
+        'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',
+        'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
+        'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard',
+        'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple',
+        'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
+        'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 
+        'cell phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 
+        'teddy bear', 'hair drier', 'toothbrush']
+    # Get the predicted class
+    predictions_class = [coco_labels[i] for i in list(predictions_["labels"])]
+    #  print("\npredicted classes:", predictions_class)
+    if len(predictions_class) < 1:
+        return [], [], []
+    # Get the predicted bounding boxes
+    predictions_boxes = [[(i[0], i[1]), (i[2], i[3])] for i in list(predictions_["boxes"])]
+
+    # Get the predicted prediction score
+    predictions_score = list(predictions_["scores"])
+    # print("predicted score:", predictions_score)
+
+    # Get a list of index with score greater than threshold
+    threshold = conf_thresh
+    predictions_t = [predictions_score.index(x) for x in predictions_score if x > threshold]
+    if len(predictions_t) > 0:
+        predictions_t = predictions_t  # [-1] #indices where score over threshold
+    else:
+        # no predictions esxceeding threshold
+        return [], [], []
+    # predictions in score order
+    predictions_boxes = [predictions_boxes[i] for i in predictions_t]
+    predictions_class = [predictions_class[i] for i in predictions_t]
+    predictions_scores = [predictions_score[i] for i in predictions_t]
+    return predictions_class, predictions_boxes, predictions_scores
+
+def plot_image_with_boxes(img, boxes, pred_cls, title):
+    import cv2  
+    text_size = 1
+    text_th = 2
+    rect_th = 1
+
+    sections = []
+    for i in range(len(boxes)):
+        cv2.rectangle(img, (int(boxes[i][0][0]), int(boxes[i][0][1])), (int(boxes[i][1][0]), int(boxes[i][1][1])),
+                      color=(0, 255, 0), thickness=rect_th)
+        # Write the prediction class
+        cv2.putText(img, pred_cls[i], (int(boxes[i][0][0]), int(boxes[i][0][1])), cv2.FONT_HERSHEY_SIMPLEX, text_size,
+                    (0, 255, 0), thickness=text_th)
+        sections.append( ((int(boxes[i][0][0]),
+                           int(boxes[i][0][1]),
+                           int(boxes[i][1][0]), 
+                           int(boxes[i][1][1])), (pred_cls[i])) )
+    
+
+    return img.astype(np.uint8)
+    
+def filter_boxes(predictions, conf_thresh):
+    dictionary = {}
+
+    boxes_list = []
+    scores_list = []
+    labels_list = []
+
+    for i in range(len(predictions[0]["boxes"])):
+        score = predictions[0]["scores"][i]
+        if score >= conf_thresh:
+            boxes_list.append(predictions[0]["boxes"][i])
+            scores_list.append(predictions[0]["scores"][[i]])
+            labels_list.append(predictions[0]["labels"][[i]])
+            
+    dictionary["boxes"] = np.vstack(boxes_list)
+    dictionary["scores"] = np.hstack(scores_list)
+    dictionary["labels"] = np.hstack(labels_list)
+
+    y = [dictionary]
+
+    return y
+
+def basic_cifar10_model(overfit=False):
+    '''
+    Load an example CIFAR10 model
+    '''
+    from art.estimators.classification.pytorch import PyTorchClassifier
+    
+    labels = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
+    path = './'
+    class Model(torch.nn.Module):
+        """
+        Create model for pytorch.
+        Here the model does not use maxpooling. Needed for certification tests.
+        """
+
+        def __init__(self):
+            super(Model, self).__init__()
+
+            self.conv = torch.nn.Conv2d(
+                in_channels=3, out_channels=16, kernel_size=(4, 4), dilation=(1, 1), padding=(0, 0), stride=(3, 3)
+            )
+
+            self.fullyconnected = torch.nn.Linear(in_features=1600, out_features=10)
+
+            self.relu = torch.nn.ReLU()
+
+            w_conv2d = np.load(
+                os.path.join(
+                    os.path.dirname(path),
+                    "utils/resources/models",
+                    "W_CONV2D_NO_MPOOL_CIFAR10.npy",
+                )
+            )
+            b_conv2d = np.load(
+                os.path.join(
+                    os.path.dirname(path),
+                    "utils/resources/models",
+                    "B_CONV2D_NO_MPOOL_CIFAR10.npy",
+                )
+            )
+            w_dense = np.load(
+                os.path.join(
+                    os.path.dirname(path),
+                    "utils/resources/models",
+                    "W_DENSE_NO_MPOOL_CIFAR10.npy",
+                )
+            )
+            b_dense = np.load(
+                os.path.join(
+                    os.path.dirname(path),
+                    "utils/resources/models",
+                    "B_DENSE_NO_MPOOL_CIFAR10.npy",
+                )
+            )
+
+            self.conv.weight = torch.nn.Parameter(torch.Tensor(w_conv2d))
+            self.conv.bias = torch.nn.Parameter(torch.Tensor(b_conv2d))
+            self.fullyconnected.weight = torch.nn.Parameter(torch.Tensor(w_dense))
+            self.fullyconnected.bias = torch.nn.Parameter(torch.Tensor(b_dense))
+
+        # pylint: disable=W0221
+        # disable pylint because of API requirements for function
+        def forward(self, x):
+            """
+            Forward function to evaluate the model
+            :param x: Input to the model
+            :return: Prediction of the model
+            """
+            x = self.conv(x)
+            x = self.relu(x)
+            x = x.reshape(-1, 1600)
+            x = self.fullyconnected(x)
+            return x
+
+    # Define the network
+    model = Model()
+    # Define a loss function and optimizer
+    if overfit:
+        loss_fn = torch.nn.CrossEntropyLoss(reduction="sum")
+        optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=0.0)
+    else:
+        loss_fn = torch.nn.CrossEntropyLoss(reduction="sum")
+        optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
+
+    # Get classifier
+    jptc = PyTorchClassifier(
+        model=model, loss=loss_fn, optimizer=optimizer, input_shape=(3, 32, 32), nb_classes=10, clip_values=(0, 1), labels=labels
+    )
+    return jptc
+
+def det_evasion_evaluate(*args):
+    '''
+    Run a detection task evaluation
+    '''
+    
+def clf_evasion_evaluate(*args):
+    '''
+    Run a classification task evaluation
+    '''
+    
+def show_model_params(model_type):
+    '''
+    Show model parameters based on selected model type
+    '''
+    if model_type!="Example CIFAR10" and model_type!="Example XView" and model_type!="CIFAR10 Overfit":
+        return gr.Column(visible=True)
+    return gr.Column(visible=False)
+    
+def show_dataset_params(dataset_type):
+    '''
+    Show dataset parameters based on dataset type
+    '''
+    if dataset_type=="Example CIFAR10":
+        return [gr.Column(visible=False), gr.Row(visible=False), gr.Row(visible=False)]
+    elif dataset_type=="local":
+        return [gr.Column(visible=True), gr.Row(visible=True), gr.Row(visible=False)]
+    return [gr.Column(visible=True), gr.Row(visible=False), gr.Row(visible=True)]
+  
+def pgd_show_label_output(dataset_type):
+    '''
+    Show PGD output component based on dataset type
+    '''
+    if dataset_type=="local":
+        return [gr.Label(visible=True), gr.Label(visible=True), gr.Number(visible=False), gr.Number(visible=False), gr.Number(visible=True)]
+    return [gr.Label(visible=False), gr.Label(visible=False), gr.Number(visible=True), gr.Number(visible=True), gr.Number(visible=True)]
+
+def pgd_update_epsilon(clip_values):
+    '''
+    Update max value of PGD epsilon slider based on model clip values
+    '''
+    if clip_values == 255:
+        return gr.Slider(minimum=0.0001, maximum=255, label="Epslion", value=55) 
+    return gr.Slider(minimum=0.0001, maximum=1, label="Epslion", value=0.05) 
+
+def patch_show_label_output(dataset_type):
+    '''
+    Show adversarial patch output components based on dataset type
+    '''
+    if dataset_type=="local":
+        return [gr.Label(visible=True), gr.Label(visible=True), gr.Number(visible=False), gr.Number(visible=False), gr.Number(visible=True)]
+    return [gr.Label(visible=False), gr.Label(visible=False), gr.Number(visible=True), gr.Number(visible=True), gr.Number(visible=True)]
+
+# e.g. To use a local alternative theme: carbon_theme = Carbon()
+carbon_theme = Carbon()
+with gr.Blocks(css=css, theme=carbon_theme) as demo:
+    import art
+    text = art.__version__
+    gr.Markdown(f"<h1>ART (v{text}) Gradio Example</h1>")
+    
+    with gr.Tab("Info"):
+        gr.Markdown('This is step 1. Using the tabs, select a task for evaluation.')
+    
+    with gr.Tab("Classification", elem_classes="task-tab"):
+        gr.Markdown("Classifying images with a set of categories.")
+        
+        # Model and Dataset Selection
+        with gr.Row():
+            # Model and Dataset type e.g. Torchvision, HuggingFace, local etc.
+            with gr.Column():
+                model_type = gr.Radio(label="Model type", choices=["Example CIFAR10", "Huggingface", "torchvision"],
+                                    value="Example CIFAR10")
+                dataset_type = gr.Radio(label="Dataset", choices=["Example CIFAR10", "Huggingface", "local"],
+                                    value="Example CIFAR10")
+            # Model parameters e.g. RESNET, VIT, input dimensions, clipping values etc.
+            with gr.Column(visible=False) as model_params:
+                model_path = gr.Textbox(placeholder="URL", label="Model path")
+                with gr.Row():
+                    with gr.Column():
+                        model_channels = gr.Textbox(placeholder="Integer, 3 for RGB images", label="Input Channels", value=3)
+                    with gr.Column():
+                        model_width = gr.Textbox(placeholder="Integer", label="Input Width", value=640)
+                with gr.Row():
+                    with gr.Column():
+                        model_height = gr.Textbox(placeholder="Integer", label="Input Height", value=480)
+                    with gr.Column():
+                        model_clip = gr.Radio(choices=[1, 255], label="Pixel clip", value=1)
+            # Dataset parameters e.g. Torchvision, HuggingFace, local etc. 
+            with gr.Column(visible=False) as dataset_params:
+                with gr.Row() as local_image:
+                    image = gr.Image(sources=['upload'], type="pil", height=150, width=150, elem_classes="input-image")
+                with gr.Row() as hosted_image:
+                    dataset_path = gr.Textbox(placeholder="URL", label="Dataset path")
+                    dataset_split = gr.Textbox(placeholder="test", label="Dataset split")
+            
+            model_type.change(show_model_params, model_type, model_params)
+            dataset_type.change(show_dataset_params, dataset_type, [dataset_params, local_image, hosted_image])
+        
+        # Attack Selection
+        with gr.Row():
+            
+            with gr.Tab("Info"):
+                gr.Markdown("This is step 2. Select the type of attack for evaluation.")
+                
+            with gr.Tab("White Box"):
+                gr.Markdown("White box attacks assume the attacker has __full access__ to the model.")
+                
+                with gr.Tab("Info"):
+                    gr.Markdown("This is step 3. Select the type of white-box attack to evaluate.")
+                
+                with gr.Tab("Evasion"):
+                    gr.Markdown("Evasion attacks are deployed to cause a model to incorrectly classify or detect items/objects in an image.")
+                    
+                    with gr.Tab("Info"):
+                        gr.Markdown("This is step 4. Select the type of Evasion attack to evaluate.")
+                    
+                    with gr.Tab("Projected Gradient Descent"):
+                        gr.Markdown("This attack uses PGD to identify adversarial examples.")
+                        
+                        
+                        with gr.Row():
+                            
+                            with gr.Column():
+                                attack = gr.Textbox(visible=True, value="PGD", label="Attack", interactive=False)
+                                max_iter = gr.Slider(minimum=1, maximum=5000, label="Max iterations", value=1000)
+                                eps = gr.Slider(minimum=0.0001, maximum=1, label="Epslion", value=0.05) 
+                                eps_steps = gr.Slider(minimum=0.001, maximum=1000, label="Epsilon steps", value=0.1) 
+                                targeted = gr.Textbox(placeholder="Target label (integer)", label="Target")
+                                eval_btn_pgd = gr.Button("Evaluate")
+                                model_clip.change(pgd_update_epsilon, model_clip, eps)
+                                
+                            # Evaluation Output. Visualisations of success/failures of running evaluation attacks.
+                            with gr.Column():
+                                with gr.Row():
+                                    with gr.Column():
+                                        original_gallery = gr.Gallery(label="Original", preview=True, show_download_button=True)
+                                        benign_output = gr.Label(num_top_classes=3, visible=False)
+                                        clean_accuracy = gr.Number(label="Clean Accuracy", precision=2)
+                                        quality_plot = gr.LinePlot(label="Gradient Quality", x='iteration', y='value', color='metric',
+                                                                   x_title='Iteration', y_title='Avg in Gradients (%)', 
+                                                                   caption="""Illustrates the average percent of zero, infinity 
+                                                                   or NaN gradients identified in images
+                                                                   across all batches.""", elem_classes="plot-padding", visible=False)
+                                        
+                                    with gr.Column():
+                                        adversarial_gallery = gr.Gallery(label="Adversarial", preview=True, show_download_button=True)
+                                        adversarial_output = gr.Label(num_top_classes=3, visible=False)
+                                        robust_accuracy = gr.Number(label="Robust Accuracy", precision=2)
+                                        perturbation_added = gr.Number(label="Perturbation Added", precision=2)
+                                        
+                                dataset_type.change(pgd_show_label_output, dataset_type, [benign_output, adversarial_output, 
+                                                                                      clean_accuracy, robust_accuracy, perturbation_added])
+                                eval_btn_pgd.click(clf_evasion_evaluate, inputs=[attack, model_type, model_path, model_channels, model_height, model_width,
+                                                                             model_clip, max_iter, eps, eps_steps, targeted, 
+                                                                             dataset_type, dataset_path, dataset_split, image],
+                                                    outputs=[original_gallery, benign_output, adversarial_gallery, adversarial_output, clean_accuracy,
+                                                             robust_accuracy, perturbation_added, quality_plot], api_name='patch')
+                        
+                        with gr.Row():
+                            clear_btn = gr.ClearButton([image, targeted, original_gallery, benign_output, clean_accuracy,
+                                                        adversarial_gallery, adversarial_output, robust_accuracy, perturbation_added])
+                            
+
+                    
+                    with gr.Tab("Adversarial Patch"):
+                        gr.Markdown("This attack crafts an adversarial patch that facilitates evasion.")
+                        
+                        with gr.Row():
+                            
+                            with gr.Column():
+                                attack = gr.Textbox(visible=True, value="Adversarial Patch", label="Attack", interactive=False)
+                                max_iter = gr.Slider(minimum=1, maximum=5000, label="Max iterations", value=100)
+                                x_location = gr.Slider(minimum=1, maximum=640, label="Location (x)", value=18) 
+                                y_location = gr.Slider(minimum=1, maximum=480, label="Location (y)", value=18) 
+                                patch_height = gr.Slider(minimum=1, maximum=640, label="Patch height", value=18) 
+                                patch_width = gr.Slider(minimum=1, maximum=480, label="Patch width", value=18) 
+                                targeted = gr.Textbox(placeholder="Target label (integer)", label="Target")
+                                eval_btn_patch = gr.Button("Evaluate")
+                                model_clip.change()
+                                
+                            # Evaluation Output. Visualisations of success/failures of running evaluation attacks.
+                            with gr.Column():
+                                with gr.Row():
+                                    with gr.Column():
+                                        original_gallery = gr.Gallery(label="Original", preview=True, show_download_button=True)
+                                        benign_output = gr.Label(num_top_classes=3, visible=False)
+                                        clean_accuracy = gr.Number(label="Clean Accuracy", precision=2)
+                                        
+                                    with gr.Column():
+                                        adversarial_gallery = gr.Gallery(label="Adversarial", preview=True, show_download_button=True)
+                                        adversarial_output = gr.Label(num_top_classes=3, visible=False)
+                                        robust_accuracy = gr.Number(label="Robust Accuracy", precision=2)
+                                        patch_image = gr.Image(label="Adversarial Patch")
+                                        
+                                dataset_type.change(patch_show_label_output, dataset_type, [benign_output, adversarial_output, 
+                                                                                      clean_accuracy, robust_accuracy, patch_image])
+                                eval_btn_patch.click(clf_evasion_evaluate, inputs=[attack, model_type, model_path, model_channels, model_height, model_width,
+                                                                             model_clip, max_iter, x_location, y_location, patch_height, patch_width, targeted, 
+                                                                             dataset_type, dataset_path, dataset_split, image],
+                                                    outputs=[original_gallery, benign_output, adversarial_gallery, adversarial_output, clean_accuracy,
+                                                             robust_accuracy, patch_image])
+                        
+                        with gr.Row():
+                            clear_btn = gr.ClearButton([image, targeted, original_gallery, benign_output, clean_accuracy,
+                                                        adversarial_gallery, adversarial_output, robust_accuracy, patch_image])
+                        
+                with gr.Tab("Poisoning"):
+                    gr.Markdown("Coming soon.")
+            
+            with gr.Tab("Black Box"):
+                gr.Markdown("Black box attacks assume the attacker __does not__ have full access to the model but can query it for predictions.")
+                
+                with gr.Tab("Info"):
+                    gr.Markdown("This is step 3. Select the type of black-box attack to evaluate.")
+                    
+                with gr.Tab("Evasion"):
+                    
+                    gr.Markdown("Evasion attacks are deployed to cause a model to incorrectly classify or detect items/objects in an image.")
+                    
+                    with gr.Tab("Info"):
+                        gr.Markdown("This is step 4. Select the type of Evasion attack to evaluate.")
+                    
+                    with gr.Tab("HopSkipJump"):
+                        gr.Markdown("Coming soon.")
+                    
+                    with gr.Tab("Square Attack"):
+                        gr.Markdown("Coming soon.")
+                        
+            with gr.Tab("AutoAttack"):
+                gr.Markdown("Coming soon.")
+            
+            
+if __name__ == "__main__":
+    
+    # during development, set debug=True
+    demo.launch(show_api=False, debug=True, share=False,
+                server_name="0.0.0.0", 
+                server_port=7777, 
+                ssl_verify=False,
+                max_threads=20)

carbon_colors.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+
+class Color:
+    all = []
+
+    def __init__(
+        self,
+        c50: str,
+        c100: str,
+        c200: str,
+        c300: str,
+        c400: str,
+        c500: str,
+        c600: str,
+        c700: str,
+        c800: str,
+        c900: str,
+        c950: str,
+        name: str | None = None,
+    ):
+        self.c50 = c50
+        self.c100 = c100
+        self.c200 = c200
+        self.c300 = c300
+        self.c400 = c400
+        self.c500 = c500
+        self.c600 = c600
+        self.c700 = c700
+        self.c800 = c800
+        self.c900 = c900
+        self.c950 = c950
+        self.name = name
+        Color.all.append(self)
+
+    def expand(self) -> list[str]:
+        return [
+            self.c50,
+            self.c100,
+            self.c200,
+            self.c300,
+            self.c400,
+            self.c500,
+            self.c600,
+            self.c700,
+            self.c800,
+            self.c900,
+            self.c950,
+        ]
+
+
+black = Color(
+    name="black",
+    c50="#000000",
+    c100="#000000",
+    c200="#000000",
+    c300="#000000",
+    c400="#000000",
+    c500="#000000",
+    c600="#000000",
+    c700="#000000",
+    c800="#000000",
+    c900="#000000",
+    c950="#000000",
+)
+
+blackHover = Color(
+    name="blackHover",
+    c50="#212121",
+    c100="#212121",
+    c200="#212121",
+    c300="#212121",
+    c400="#212121",
+    c500="#212121",
+    c600="#212121",
+    c700="#212121",
+    c800="#212121",
+    c900="#212121",
+    c950="#212121",
+)
+
+white = Color(
+    name="white",
+    c50="#ffffff",
+    c100="#ffffff",
+    c200="#ffffff",
+    c300="#ffffff",
+    c400="#ffffff",
+    c500="#ffffff",
+    c600="#ffffff",
+    c700="#ffffff",
+    c800="#ffffff",
+    c900="#ffffff",
+    c950="#ffffff",
+)
+
+whiteHover = Color(
+    name="whiteHover",
+    c50="#e8e8e8",
+    c100="#e8e8e8",
+    c200="#e8e8e8",
+    c300="#e8e8e8",
+    c400="#e8e8e8",
+    c500="#e8e8e8",
+    c600="#e8e8e8",
+    c700="#e8e8e8",
+    c800="#e8e8e8",
+    c900="#e8e8e8",
+    c950="#e8e8e8",
+)
+
+red = Color(
+    name="red",
+    c50="#fff1f1",
+    c100="#ffd7d9",
+    c200="#ffb3b8",
+    c300="#ff8389",
+    c400="#fa4d56",
+    c500="#da1e28",
+    c600="#a2191f",
+    c700="#750e13",
+    c800="#520408",
+    c900="#2d0709",
+    c950="#2d0709",
+)
+
+redHover = Color(
+    name="redHover",
+    c50="#540d11",
+    c100="#66050a",
+    c200="#921118",
+    c300="#c21e25",
+    c400="#b81922",
+    c500="#ee0713",
+    c600="#ff6168",
+    c700="#ff99a0",
+    c800="#ffc2c5",
+    c900="#ffe0e0",
+    c950="#ffe0e0",
+)
+
+blue = Color(
+    name="blue",
+    c50="#edf5ff",
+    c100="#d0e2ff",
+    c200="#a6c8ff",
+    c300="#78a9ff",
+    c400="#4589ff",
+    c500="#0f62fe",
+    c600="#0043ce",
+    c700="#002d9c",
+    c800="#001d6c",
+    c900="#001141",
+    c950="#001141",
+)
+
+blueHover = Color(
+    name="blueHover",
+    
+    c50="#001f75",
+    c100="#00258a",
+    c200="#0039c7",
+    c300="#0053ff",
+    c400="#0050e6",
+    c500="#1f70ff",
+    c600="#5c97ff",
+    c700="#8ab6ff",
+    c800="#b8d3ff",
+    c900="#dbebff",
+    c950="#dbebff",
+)
+
+

carbon_theme.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+from gradio.themes.base import Base
+from gradio.themes.utils import colors, fonts, sizes
+import carbon_colors
+
+
+class Carbon(Base):
+    def __init__(
+        self,
+        *,
+        primary_hue: carbon_colors.Color | str = carbon_colors.white,
+        secondary_hue: carbon_colors.Color | str = carbon_colors.red,
+        neutral_hue: carbon_colors.Color | str = carbon_colors.blue,
+        spacing_size: sizes.Size | str = sizes.spacing_lg,
+        radius_size: sizes.Size | str = sizes.radius_none,
+        text_size: sizes.Size | str = sizes.text_md,
+        font: fonts.Font
+        | str
+        | Iterable[fonts.Font | str] = (
+            fonts.GoogleFont("IBM Plex Mono"),
+            fonts.GoogleFont("IBM Plex Sans"),
+            fonts.GoogleFont("IBM Plex Serif"),
+        ),
+        font_mono: fonts.Font
+        | str
+        | Iterable[fonts.Font | str] = (
+            fonts.GoogleFont("IBM Plex Mono"),
+        ),
+    ):
+        super().__init__(
+            primary_hue=primary_hue,
+            secondary_hue=secondary_hue,
+            neutral_hue=neutral_hue,
+            spacing_size=spacing_size,
+            radius_size=radius_size,
+            text_size=text_size,
+            font=font,
+            font_mono=font_mono,
+        )
+        self.name = "carbon"
+        super().set(
+            # Colors 
+            slider_color="*neutral_900", 
+            slider_color_dark="*neutral_500",
+            body_text_color="*neutral_900",
+            block_label_text_color="*body_text_color",
+            block_title_text_color="*body_text_color",
+            body_text_color_subdued="*neutral_700",
+            background_fill_primary_dark="*neutral_900",
+            background_fill_secondary_dark="*neutral_800",
+            block_background_fill_dark="*neutral_800",
+            input_background_fill_dark="*neutral_700",
+            # Button Colors
+            button_primary_background_fill=carbon_colors.blue.c500,
+            button_primary_background_fill_hover="*neutral_300",
+            button_primary_text_color="white",
+            button_primary_background_fill_dark="*neutral_600",
+            button_primary_background_fill_hover_dark="*neutral_600",
+            button_primary_text_color_dark="white",
+            button_secondary_background_fill="*button_primary_background_fill",
+            button_secondary_background_fill_hover="*button_primary_background_fill_hover",
+            button_secondary_text_color="*button_primary_text_color",
+            button_cancel_background_fill="*button_primary_background_fill",
+            button_cancel_background_fill_hover="*button_primary_background_fill_hover",
+            button_cancel_text_color="*button_primary_text_color",
+            checkbox_background_color=carbon_colors.black.c50,
+            checkbox_label_background_fill="*button_primary_background_fill",
+            checkbox_label_background_fill_hover="*button_primary_background_fill_hover",
+            checkbox_label_text_color="*button_primary_text_color",
+            checkbox_background_color_selected=carbon_colors.black.c50,
+            checkbox_border_width="1px",
+            checkbox_border_width_dark="1px",
+            checkbox_border_color=carbon_colors.white.c50,
+            checkbox_border_color_dark=carbon_colors.white.c50,
+            
+            checkbox_border_color_focus=carbon_colors.blue.c900,
+            checkbox_border_color_focus_dark=carbon_colors.blue.c900,
+            checkbox_border_color_selected=carbon_colors.white.c50,
+            checkbox_border_color_selected_dark=carbon_colors.white.c50,
+            
+            checkbox_background_color_hover=carbon_colors.black.c50,
+            checkbox_background_color_hover_dark=carbon_colors.black.c50,
+            checkbox_background_color_dark=carbon_colors.black.c50,
+            checkbox_background_color_selected_dark=carbon_colors.black.c50,
+            # Padding
+            checkbox_label_padding="16px",
+            button_large_padding="*spacing_lg",
+            button_small_padding="*spacing_sm",
+            # Borders
+            block_border_width="0px",
+            block_border_width_dark="1px",
+            shadow_drop_lg="0 1px 4px 0 rgb(0 0 0 / 0.1)",
+            block_shadow="*shadow_drop_lg",
+            block_shadow_dark="none",
+            # Block Labels
+            block_title_text_weight="600",
+            block_label_text_weight="600",
+            block_label_text_size="*text_md",
+        )

requirements.txt

@@ -0,0 +1,9 @@
+gradio
+adversarial-robustness-toolbox
+pandas
+jupyter
+
+torch==1.13.1
+tensorflow==2.10.1; sys_platform != "darwin"
+tensorflow-macos; sys_platform == "darwin"
+tensorflow-metal; sys_platform == "darwin"