Push updates from pre-prod

app.py

@@ -26,6 +26,85 @@ css = """
 }
 """
 
+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():
     '''
     Load an example CIFAR10 model
@@ -112,6 +191,186 @@ def basic_cifar10_model():
     )
     return jptc
 
+def det_evasion_evaluate(*args):
+    '''
+    Run a detection task evaluation
+    '''
+    
+    attack = args[0]
+    model_type = args[1]
+    
+    box_thresh = args[-3]
+    dataset_type = args[-2]
+    image = args[-1]
+    
+    if dataset_type == "COCO":
+        from torchvision.transforms import transforms
+        import requests
+        from PIL import Image
+        NUMBER_CHANNELS = 3
+        INPUT_SHAPE = (NUMBER_CHANNELS, 640, 640)
+
+        transform = transforms.Compose([
+                transforms.Resize(INPUT_SHAPE[1], interpolation=transforms.InterpolationMode.BICUBIC),
+                transforms.CenterCrop(INPUT_SHAPE[1]),
+                transforms.ToTensor()
+            ])
+
+        urls = ['http://images.cocodataset.org/val2017/000000039769.jpg',
+        'http://images.cocodataset.org/val2017/000000397133.jpg',
+        'http://images.cocodataset.org/val2017/000000037777.jpg',
+        'http://images.cocodataset.org/val2017/000000454661.jpg',
+        'http://images.cocodataset.org/val2017/000000094852.jpg']
+
+        coco_images = []
+        for url in urls:
+            im = Image.open(requests.get(url, stream=True).raw)
+            im = transform(im).numpy()
+            coco_images.append(im)
+        image = np.array(coco_images)*255  
+        
+    if model_type == "YOLOv5":
+        from heart.estimators.object_detection.pytorch_yolo import JaticPyTorchYolo
+        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']
+        detector = JaticPyTorchYolo(device_type='cpu',
+                            input_shape=(3, 640, 640),
+                            clip_values=(0, 255), 
+                            attack_losses=("loss_total", "loss_cls",
+                                        "loss_box",
+                                        "loss_obj"),
+                            labels=coco_labels)
+    
+    if attack=="PGD":
+        
+        from art.attacks.evasion import ProjectedGradientDescent
+        from heart.attacks.attack import JaticAttack
+        from heart.metrics import AccuracyPerturbationMetric
+        from torch.nn.functional import softmax
+        from maite.protocols import HasDataImage, is_typed_dict
+        
+        pgd_attack = ProjectedGradientDescent(estimator=detector, max_iter=args[7], eps=args[8],
+                                                 eps_step=args[9], targeted=args[10]!="")
+        attack = JaticAttack(pgd_attack)
+        
+        benign_output = detector(image)
+        
+        dets = [{'boxes': benign_output.boxes[i],
+            'scores': benign_output.scores[i],
+            'labels': benign_output.labels[i]} for i in range(len(image))]
+
+        y = [filter_boxes([t], 0.8)[0] for t in dets]
+        if args[10]!="":
+            data = {'image': image[[0]], 'label': y[-1:]}
+        else:
+            data = image
+        
+        
+        output = attack.run_attack(data=data)
+        adv_output = detector(output.adversarial_examples)
+        out_imgs = []
+        for i in range(len(output.adversarial_examples)):
+            pred = {'boxes': adv_output.boxes[i],
+                    'scores': adv_output.scores[i],
+                    'labels': adv_output.labels[i]}
+            preds_orig = extract_predictions(pred, box_thresh)
+            out_img = plot_image_with_boxes(img=output.adversarial_examples[i].transpose(1,2,0).copy(),
+                                        boxes=preds_orig[1], pred_cls=preds_orig[0], title="Detections")
+            out_imgs.append(out_img)
+    
+        out_imgs_benign = []
+        for i in range(len(image)):
+            pred = {'boxes': benign_output.boxes[i],
+                    'scores': benign_output.scores[i],
+                    'labels': benign_output.labels[i]}
+            preds_benign = extract_predictions(pred, box_thresh)
+            out_img = plot_image_with_boxes(img=image[i].transpose(1,2,0).copy(),
+                                        boxes=preds_benign[1], pred_cls=preds_benign[0], title="Detections")
+            out_imgs_benign.append(out_img)
+        
+        
+        image = []
+        for i, img in enumerate(out_imgs_benign):
+            image.append(img.astype(np.uint8))
+        
+        adv_imgs = []
+        for i, img in enumerate(out_imgs):
+            adv_imgs.append(img.astype(np.uint8))
+        
+        return [image, adv_imgs]
+
+    elif attack=="Adversarial Patch":
+        from art.attacks.evasion.adversarial_patch.adversarial_patch_pytorch import AdversarialPatchPyTorch
+        from heart.attacks.attack import JaticAttack
+        from heart.metrics import AccuracyPerturbationMetric
+        from torch.nn.functional import softmax
+        from maite.protocols import HasDataImage, is_typed_dict
+        
+
+        batch_size = 16
+        scale_min = 0.3
+        scale_max = 1.0
+        rotation_max = 0
+        learning_rate = 5000.
+
+        patch_attack = AdversarialPatchPyTorch(estimator=detector, rotation_max=rotation_max, patch_location=(args[8], args[9]),
+                            scale_min=scale_min, scale_max=scale_max, patch_type='circle',
+                            learning_rate=learning_rate, max_iter=args[7], batch_size=batch_size,
+                            patch_shape=(3, args[10], args[11]), verbose=False, targeted=args[-4]=="Yes")
+        
+        attack = JaticAttack(patch_attack)
+        
+        benign_output = detector(image)
+        
+        dets = [{'boxes': benign_output.boxes[i],
+            'scores': benign_output.scores[i],
+            'labels': benign_output.labels[i]} for i in range(len(image))]
+
+        if args[-4]=="Yes":
+            data = {'image': image, 'label':[dets[-1] for i in image]}
+        else:
+            data = {'image': image, 'label': dets}
+        
+        output = attack.run_attack(data=data)
+        adv_output = detector(output.adversarial_examples)
+        out_imgs = []
+        for i in range(len(output.adversarial_examples)):
+            pred = {'boxes': adv_output.boxes[i],
+                    'scores': adv_output.scores[i],
+                    'labels': adv_output.labels[i]}
+            preds_orig = extract_predictions(pred, box_thresh)
+            out_img = plot_image_with_boxes(img=output.adversarial_examples[i].transpose(1,2,0).copy(),
+                                        boxes=preds_orig[1], pred_cls=preds_orig[0], title="Detections")
+            out_imgs.append(out_img)
+    
+        out_imgs_benign = []
+        for i in range(len(image)):
+            pred = {'boxes': benign_output.boxes[i],
+                    'scores': benign_output.scores[i],
+                    'labels': benign_output.labels[i]}
+            preds_benign = extract_predictions(pred, box_thresh)
+            out_img = plot_image_with_boxes(img=image[i].transpose(1,2,0).copy(),
+                                        boxes=preds_benign[1], pred_cls=preds_benign[0], title="Detections")
+            out_imgs_benign.append(out_img)
+        
+        
+        image = []
+        for i, img in enumerate(out_imgs_benign):
+            image.append(img.astype(np.uint8))
+        
+        adv_imgs = []
+        for i, img in enumerate(out_imgs):
+            adv_imgs.append(img.astype(np.uint8))
+        
+        return [image, adv_imgs]
+
 def clf_evasion_evaluate(*args):
     '''
     Run a classification task evaluation
@@ -421,9 +680,6 @@ def show_target_label_dataframe(dataset_type):
 with gr.Blocks(css=css, theme='xiaobaiyuan/theme_brief') as demo:
     gr.Markdown("<h1>HEART Adversarial Robustness 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.")
         
@@ -463,19 +719,19 @@ with gr.Blocks(css=css, theme='xiaobaiyuan/theme_brief') as demo:
         with gr.Row():
             
             with gr.Tab("Info"):
-                gr.Markdown("This is step 2. Select the type of attack for evaluation.")
+                gr.Markdown("This is step 1. 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.")
+                    gr.Markdown("This is step 2. 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.")
+                        gr.Markdown("This is step 3. Select the type of Evasion attack to evaluate.")
                     
                     with gr.Tab("Projected Gradient Descent"):
                         gr.Markdown("This attack uses PGD to identify adversarial examples.")
@@ -483,11 +739,11 @@ with gr.Blocks(css=css, theme='xiaobaiyuan/theme_brief') as demo:
                         
                         with gr.Row():
                             
-                            with gr.Column():
+                            with gr.Column(scale=1):
                                 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) 
+                                max_iter = gr.Slider(minimum=1, maximum=20, label="Max iterations", value=10, step=1)
+                                eps = gr.Slider(minimum=0.03, maximum=1, label="Epslion", value=0.03) 
+                                eps_steps = gr.Slider(minimum=0.003, maximum=0.99, label="Epsilon steps", value=0.003) 
                                 targeted = gr.Textbox(placeholder="Target label (integer)", label="Target")
                                 with gr.Accordion("Target mapping", open=False):
                                     cifar_labels = gr.Dataframe(pd.DataFrame(['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck'],
@@ -504,7 +760,7 @@ with gr.Blocks(css=css, theme='xiaobaiyuan/theme_brief') as demo:
                                 dataset_type.change(show_target_label_dataframe, dataset_type, [cifar_labels, xview_labels])
                                 
                             # Evaluation Output. Visualisations of success/failures of running evaluation attacks.
-                            with gr.Column():
+                            with gr.Column(scale=2):
                                 with gr.Row():
                                     with gr.Column():
                                         original_gallery = gr.Gallery(label="Original", preview=True, height=600)
@@ -529,20 +785,18 @@ with gr.Blocks(css=css, theme='xiaobaiyuan/theme_brief') as demo:
                             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():
+                            with gr.Column(scale=1):
                                 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) 
+                                max_iter = gr.Slider(minimum=1, maximum=20, label="Max iterations", value=2, step=1)
+                                x_location = gr.Slider(minimum=1, maximum=640, label="Location (x)", value=18, step=1) 
+                                y_location = gr.Slider(minimum=1, maximum=480, label="Location (y)", value=18, step=1) 
+                                patch_height = gr.Slider(minimum=1, maximum=640, label="Patch height", value=18, step=1) 
+                                patch_width = gr.Slider(minimum=1, maximum=480, label="Patch width", value=18, step=1) 
                                 targeted = gr.Textbox(placeholder="Target label (integer)", label="Target")
                                 with gr.Accordion("Target mapping", open=False):
                                     cifar_labels = gr.Dataframe(pd.DataFrame(['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck'],
@@ -559,7 +813,7 @@ with gr.Blocks(css=css, theme='xiaobaiyuan/theme_brief') as demo:
                                 dataset_type.change(show_target_label_dataframe, dataset_type, [cifar_labels, xview_labels])
                                 
                             # Evaluation Output. Visualisations of success/failures of running evaluation attacks.
-                            with gr.Column():
+                            with gr.Column(scale=2):
                                 with gr.Row():
                                     with gr.Column():
                                         original_gallery = gr.Gallery(label="Original", preview=True, height=600)
@@ -591,14 +845,14 @@ with gr.Blocks(css=css, theme='xiaobaiyuan/theme_brief') as demo:
                 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.")
+                    gr.Markdown("This is step 2. 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.")
+                        gr.Markdown("This is step 3. Select the type of Evasion attack to evaluate.")
                     
                     with gr.Tab("HopSkipJump"):
                         gr.Markdown("Coming soon.")
@@ -612,7 +866,133 @@ with gr.Blocks(css=css, theme='xiaobaiyuan/theme_brief') as demo:
             
     with gr.Tab("Object Detection"):
         gr.Markdown("Extracting objects from images and identifying their category.")
-        gr.Markdown("Coming soon.")
+        
+        # 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=["YOLOv5"],
+                                    value="YOLOv5")
+                dataset_type = gr.Radio(label="Dataset", choices=["COCO",],
+                                    value="COCO")
+            
+            model_type.change(show_model_params, model_type, model_params)
+            dataset_type.change(show_dataset_params, dataset_type, [dataset_params, local_image])
+        
+        # Attack Selection
+        with gr.Row():
+            
+            with gr.Tab("Info"):
+                gr.Markdown("This is step 1. 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 2. 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 3. 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(scale=1):
+                                attack = gr.Textbox(visible=True, value="PGD", label="Attack", interactive=False)
+                                max_iter = gr.Slider(minimum=1, maximum=10, label="Max iterations", value=4, step=1)
+                                eps = gr.Slider(minimum=8, maximum=255, label="Epslion", value=8, step=1) 
+                                eps_steps = gr.Slider(minimum=1, maximum=254, label="Epsilon steps", value=1, step=1) 
+                                targeted = gr.Textbox(placeholder="Target label (integer)", label="Target")
+                                det_threshold = gr.Slider(minimum=0.0, maximum=100, label="Detection threshold", value=0.2)
+                                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(scale=3):
+                                with gr.Row():
+                                    with gr.Column():
+                                        original_gallery = gr.Gallery(label="Original", preview=True, show_download_button=True, height=600)
+                                        
+                                    with gr.Column():
+                                        adversarial_gallery = gr.Gallery(label="Adversarial", preview=True, show_download_button=True, height=600)
+                                        
+                                eval_btn_pgd.click(det_evasion_evaluate, inputs=[attack, model_type, model_path, model_channels, model_height, model_width,
+                                                                             model_clip, max_iter, eps, eps_steps, targeted, 
+                                                                             det_threshold, dataset_type, image],
+                                                    outputs=[original_gallery, adversarial_gallery], api_name='patch')
+                        
+                        with gr.Row():
+                            clear_btn = gr.ClearButton([image, original_gallery,
+                                                        adversarial_gallery])
+                            
+
+                    
+                    with gr.Tab("Adversarial Patch"):
+                        gr.Markdown("This attack crafts an adversarial patch that facilitates evasion.")
+                        
+                        with gr.Row():
+                            
+                            with gr.Column(scale=1):
+                                attack = gr.Textbox(visible=True, value="Adversarial Patch", label="Attack", interactive=False)
+                                max_iter = gr.Slider(minimum=1, maximum=100, label="Max iterations", value=1, step=1)
+                                x_location = gr.Slider(minimum=1, maximum=640, label="Location (x)", value=100, step=1) 
+                                y_location = gr.Slider(minimum=1, maximum=480, label="Location (y)", value=100, step=1) 
+                                patch_height = gr.Slider(minimum=1, maximum=640, label="Patch height", value=100, step=1) 
+                                patch_width = gr.Slider(minimum=1, maximum=480, label="Patch width", value=100, step=1) 
+                                targeted = gr.Radio(choices=['Yes', 'No'], value='No', label="Targeted")
+                                det_threshold = gr.Slider(minimum=0.0, maximum=100, label="Detection threshold", value=0.2)
+                                eval_btn_patch = gr.Button("Evaluate")
+                                model_clip.change()
+                                
+                            # Evaluation Output. Visualisations of success/failures of running evaluation attacks.
+                            with gr.Column(scale=3):
+                                with gr.Row():
+                                    with gr.Column():
+                                        original_gallery = gr.Gallery(label="Original", preview=True, show_download_button=True, height=600)
+                                        
+                                    with gr.Column():
+                                        adversarial_gallery = gr.Gallery(label="Adversarial", preview=True, show_download_button=True, height=600)
+                                        
+                                dataset_type.change(patch_show_label_output, dataset_type, [adversarial_output, ])
+                                eval_btn_patch.click(det_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, 
+                                                                             det_threshold,dataset_type, image],
+                                                    outputs=[original_gallery, adversarial_gallery])
+                        
+                        with gr.Row():
+                            clear_btn = gr.ClearButton([image, targeted, original_gallery,
+                                                        adversarial_gallery])
+                        
+                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 2. 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 3. 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__":
 
@@ -629,5 +1009,5 @@ if __name__ == "__main__":
     subprocess.run([sys.executable, '-m', 'pip', 'install', HEART_INSTALL])
     
     # during development, set debug=True
-    demo.launch()
+    demo.launch(debug=True)
 

requirements.txt

@@ -53,5 +53,3 @@ pycodestyle==2.8.0
 black==22.3.0
 isort==5.12.0
 
-
-