push updates to cdao prod

README.md

@@ -5,7 +5,7 @@ colorFrom: indigo
 colorTo: blue 
 sdk: gradio
 sdk_version: 4.13.0
-app_file: app.py
+app_file: gradio/app.py
 pinned: false
 license: mit
 ---

app.py → gradio/app.py

@@ -24,7 +24,224 @@ css = """
     padding-left: 50px !important;
     padding-right: 50px !important;
 }
+
+.output-image, img {
+    border-radius: 0px !important;
+    margin: auto !important;
+} 
 """
+def update_patch_sliders(*args):
+    from maite.protocols import HasDataImage, is_typed_dict
+    
+    x_location, y_location, patch_dim, dataset_type, dataset_path, dataset_split, image = args
+    
+    if dataset_type == "Example XView":
+        from maite import load_dataset
+        import torchvision
+        jatic_dataset = load_dataset(
+            provider="huggingface",
+            dataset_name="CDAO/xview-subset-classification",
+            task="image-classification",
+            split="test",
+        )
+        IMAGE_H, IMAGE_W = 224, 224
+        transform = torchvision.transforms.Compose(
+            [  
+                torchvision.transforms.Resize((IMAGE_H, IMAGE_W)),
+                torchvision.transforms.ToTensor(),
+            ]
+        )  
+        jatic_dataset.set_transform(lambda x: {"image": transform(x["image"]), "label": x["label"]})
+        image = {'image': [i['image'].numpy() for i in jatic_dataset],
+                'label': [i['label'] for i in jatic_dataset]}
+        image = (image['image'][0].transpose(1,2,0)*255).astype(np.uint8)
+    elif dataset_type=="huggingface":
+        from maite import load_dataset
+        jatic_dataset = load_dataset(
+            provider=dataset_type,
+            dataset_name=dataset_path,
+            task="image-classification",
+            split=dataset_split,
+            drop_labels=False
+        )
+        
+        image = {'image': [i['image'] for i in jatic_dataset],
+                'label': [i['label'] for i in jatic_dataset]}
+    elif dataset_type=="torchvision":
+        from maite import load_dataset
+        jatic_dataset = load_dataset(
+            provider=dataset_type,
+            dataset_name=dataset_path,
+            task="image-classification",
+            split=dataset_split,
+            root='./data/',
+            download=True
+        )
+        image = {'image': [i['image'] for i in jatic_dataset],
+                'label': [i['label'] for i in jatic_dataset]}  
+    elif dataset_type=="Example CIFAR10":
+        from maite import load_dataset
+        jatic_dataset = load_dataset(
+            provider="torchvision",
+            dataset_name="CIFAR10",
+            task="image-classification",
+            split=dataset_split,
+            root='./data/',
+            download=True
+        )
+        image = np.array(jatic_dataset[0]['image'])
+    elif 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']
+
+        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
+        image = image[0].transpose(1,2,0).astype(np.uint8)
+        
+    if is_typed_dict(image, HasDataImage):
+        image = image['image']
+    
+    if isinstance(image, list):
+        image = image[0]
+         
+    height = image.shape[0]
+    width = image.shape[1]
+    
+    max_patch = min(height, width)
+    if patch_dim > max_patch:
+        patch_dim = max_patch
+    
+    max_x = width - (patch_dim) 
+    max_y = height - (patch_dim)
+    
+    max_x = max_x if max_x >= 0 else 0
+    max_y = max_y if max_y >= 0 else 0
+    
+    if x_location > max_x:
+        x_location = max_x
+    if y_location > max_y:
+        y_location = max_y
+    
+    return [gr.Slider(maximum=max_patch, step=1), gr.Slider(maximum=max_x, value=x_location, step=1), gr.Slider(maximum=max_y, value=y_location, step=1)]
+
+def preview_patch_location(*args):
+    '''
+    Create a gallery of images with a sample patch applied
+    '''
+    import cv2
+    from maite.protocols import HasDataImage, is_typed_dict
+
+    x_location, y_location, patch_dim = int(args[0]), int(args[1]), int(args[2])
+
+    dataset_type = args[-4]
+    dataset_path = args[-3]
+    dataset_split = args[-2]
+    image = args[-1]
+
+    if dataset_type == "Example XView":
+        from maite import load_dataset
+        import torchvision
+        jatic_dataset = load_dataset(
+            provider="huggingface",
+            dataset_name="CDAO/xview-subset-classification",
+            task="image-classification",
+            split="test",
+        )
+        IMAGE_H, IMAGE_W = 224, 224
+        transform = torchvision.transforms.Compose(
+            [  
+                torchvision.transforms.Resize((IMAGE_H, IMAGE_W)),
+                torchvision.transforms.ToTensor(),
+            ]
+        )  
+        jatic_dataset.set_transform(lambda x: {"image": transform(x["image"]), "label": x["label"]})
+        image = {'image': [i['image'].numpy() for i in jatic_dataset],
+                'label': [i['label'] for i in jatic_dataset]}
+        image = (image['image'][0].transpose(1,2,0)*255).astype(np.uint8)
+    elif dataset_type=="huggingface":
+        from maite import load_dataset
+        jatic_dataset = load_dataset(
+            provider=dataset_type,
+            dataset_name=dataset_path,
+            task="image-classification",
+            split=dataset_split,
+            drop_labels=False
+        )
+        
+        image = {'image': [i['image'] for i in jatic_dataset],
+                'label': [i['label'] for i in jatic_dataset]}
+    elif dataset_type=="torchvision":
+        from maite import load_dataset
+        jatic_dataset = load_dataset(
+            provider=dataset_type,
+            dataset_name=dataset_path,
+            task="image-classification",
+            split=dataset_split,
+            root='./data/',
+            download=True
+        )
+        image = {'image': [i['image'] for i in jatic_dataset],
+                'label': [i['label'] for i in jatic_dataset]}  
+    elif dataset_type=="Example CIFAR10":
+        from maite import load_dataset
+        jatic_dataset = load_dataset(
+            provider="torchvision",
+            dataset_name="CIFAR10",
+            task="image-classification",
+            split=dataset_split,
+            root='./data/',
+            download=True
+        )
+        image = np.array(jatic_dataset[0]['image'])
+    elif 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']
+
+        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
+        image = image[0].transpose(1,2,0).astype(np.uint8)
+        
+    if is_typed_dict(image, HasDataImage):
+        image = image['image']
+    
+    if isinstance(image, list):
+        image = image[0]
+
+    p0 = x_location, y_location
+    p1 =  x_location + (patch_dim-1), y_location + (patch_dim-1)
+    image = cv2.rectangle(cv2.UMat(image), p0, p1, (255,165,0), cv2.FILLED).get()
+    
+    return image
 
 def extract_predictions(predictions_, conf_thresh):
     coco_labels = ['person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light',
@@ -109,7 +326,7 @@ def basic_cifar10_model():
     '''
     Load an example CIFAR10 model
     '''
-    from heart.estimators.classification.pytorch import JaticPyTorchClassifier
+    from heart_library.estimators.classification.pytorch import JaticPyTorchClassifier
     
     labels = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
     path = './'
@@ -230,7 +447,7 @@ def det_evasion_evaluate(*args):
         image = np.array(coco_images)*255  
         
     if model_type == "YOLOv5":
-        from heart.estimators.object_detection.pytorch_yolo import JaticPyTorchYolo
+        from heart_library.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',
@@ -251,8 +468,8 @@ def det_evasion_evaluate(*args):
     if attack=="PGD":
         
         from art.attacks.evasion import ProjectedGradientDescent
-        from heart.attacks.attack import JaticAttack
-        from heart.metrics import AccuracyPerturbationMetric
+        from heart_library.attacks.attack import JaticAttack
+        from heart_library.metrics import AccuracyPerturbationMetric
         from torch.nn.functional import softmax
         from maite.protocols import HasDataImage, is_typed_dict
         
@@ -308,11 +525,7 @@ def det_evasion_evaluate(*args):
 
     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
-        
+        from heart_library.attacks.attack import JaticAttack
 
         batch_size = 16
         scale_min = 0.3
@@ -321,9 +534,9 @@ def det_evasion_evaluate(*args):
         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',
+                            scale_min=scale_min, scale_max=scale_max, patch_type='square',
                             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")
+                            patch_shape=(3, args[10], args[10]), verbose=False, targeted=args[-4]=="Yes")
         
         attack = JaticAttack(patch_attack)
         
@@ -368,8 +581,10 @@ def det_evasion_evaluate(*args):
         adv_imgs = []
         for i, img in enumerate(out_imgs):
             adv_imgs.append(img.astype(np.uint8))
-        
-        return [image, adv_imgs]
+            
+        patch, patch_mask = output.adversarial_patch
+        patch_image = ((patch) * patch_mask).transpose(1,2,0).astype(np.uint8)
+        return [image, adv_imgs, patch_image]
 
 def clf_evasion_evaluate(*args):
     '''
@@ -449,7 +664,7 @@ def clf_evasion_evaluate(*args):
         jptc = basic_cifar10_model()  
     elif model_type == "Example XView":
         import torchvision
-        from heart.estimators.classification.pytorch import JaticPyTorchClassifier
+        from heart_library.estimators.classification.pytorch import JaticPyTorchClassifier
         classes = {
             0:'Building',
             1:'Construction Site',
@@ -469,7 +684,7 @@ def clf_evasion_evaluate(*args):
         )
     elif model_type == "torchvision":
         from maite.interop.torchvision import TorchVisionClassifier 
-        from heart.estimators.classification.pytorch import JaticPyTorchClassifier
+        from heart_library.estimators.classification.pytorch import JaticPyTorchClassifier
         
         clf = TorchVisionClassifier.from_pretrained(model_path)
         loss_fn = torch.nn.CrossEntropyLoss(reduction="sum")
@@ -479,7 +694,7 @@ def clf_evasion_evaluate(*args):
         )
     elif model_type == "huggingface":
         from maite.interop.huggingface import HuggingFaceImageClassifier 
-        from heart.estimators.classification.pytorch import JaticPyTorchClassifier
+        from heart_library.estimators.classification.pytorch import JaticPyTorchClassifier
         
         clf = HuggingFaceImageClassifier.from_pretrained(model_path)
         loss_fn = torch.nn.CrossEntropyLoss(reduction="sum")
@@ -490,8 +705,8 @@ def clf_evasion_evaluate(*args):
     
     if attack=="PGD":
         from art.attacks.evasion.projected_gradient_descent.projected_gradient_descent_pytorch import ProjectedGradientDescentPyTorch
-        from heart.attacks.attack import JaticAttack
-        from heart.metrics import AccuracyPerturbationMetric
+        from heart_library.attacks.attack import JaticAttack
+        from heart_library.metrics import AccuracyPerturbationMetric
         from torch.nn.functional import softmax
         from maite.protocols import HasDataImage, is_typed_dict, ArrayLike
         
@@ -551,8 +766,8 @@ def clf_evasion_evaluate(*args):
 
     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 heart_library.attacks.attack import JaticAttack
+        from heart_library.metrics import AccuracyPerturbationMetric
         from torch.nn.functional import softmax
         from maite.protocols import HasDataImage, is_typed_dict, ArrayLike
         
@@ -568,7 +783,7 @@ def clf_evasion_evaluate(*args):
         patch_attack = AdversarialPatchPyTorch(estimator=jptc, rotation_max=rotation_max, patch_location=(args[8], args[9]),
                             scale_min=scale_min, scale_max=scale_max, patch_type='square',
                             learning_rate=learning_rate, max_iter=args[7], batch_size=batch_size,
-                            patch_shape=(3, args[10], args[11]), verbose=False, targeted=args[12]!="")
+                            patch_shape=(3, args[10], args[10]), verbose=False, targeted=args[11]!="")
         
         attack = JaticAttack(patch_attack)
         
@@ -578,11 +793,11 @@ def clf_evasion_evaluate(*args):
         for i, label in enumerate(jptc.get_labels()):
             labels[label] = preds[0][i]
         
-        if args[12]!="":
+        if args[11]!="":
             if is_typed_dict(image, HasDataImage):
-                data = {'image': image['image'], 'label': [args[12]]*len(image['image'])}
+                data = {'image': image['image'], 'label': [args[11]]*len(image['image'])}
             else:
-                data = {'image': image, 'label': [args[12]]}
+                data = {'image': image, 'label': [args[11]]}
         else:
             data = image
         
@@ -755,6 +970,7 @@ with gr.Blocks(css=css, theme='xiaobaiyuan/theme_brief') as demo:
                                                                 columns=['label']).rename_axis('target').reset_index(), 
                                                                 visible=False, elem_classes=["small-font", "df-padding"],
                                                                 type="pandas",interactive=False)
+                                    
                                 eval_btn_pgd = gr.Button("Evaluate")
                                 model_clip.change(pgd_update_epsilon, model_clip, eps)
                                 dataset_type.change(show_target_label_dataframe, dataset_type, [cifar_labels, xview_labels])
@@ -791,14 +1007,40 @@ with gr.Blocks(css=css, theme='xiaobaiyuan/theme_brief') as demo:
                         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=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):
+                                with gr.Accordion('Adversarial Patch Parameters', open=False):
+                                    attack = gr.Textbox(visible=True, value="Adversarial Patch", label="Attack", interactive=False)
+                                    max_iter = gr.Slider(minimum=1, maximum=20, label="Max iterations", value=2, step=1)
+                                    patch_dim = gr.Slider(minimum=1, maximum=32, label="Patch dimension", value=6, step=1, info="The height and width of the patch") 
+                                    x_location = gr.Slider(minimum=0, maximum=25, label="Location (x)", value=1, step=1, info="Shift patch left and right") 
+                                    y_location = gr.Slider(minimum=0, maximum=25, label="Location (y)", value=1, step=1, info="Shift patch up and down") 
+                                    targeted = gr.Textbox(placeholder="Target label (integer)", label="Target")
+                                    
+                                    dataset_type.change(update_patch_sliders, 
+                                                      [x_location, y_location, patch_dim, dataset_type, dataset_path, dataset_split, image],
+                                                      [patch_dim, x_location, y_location])
+                                    image.change(update_patch_sliders, 
+                                                      [x_location, y_location, patch_dim, dataset_type, dataset_path, dataset_split, image],
+                                                      [patch_dim, x_location, y_location])
+                                    patch_dim.release(update_patch_sliders, 
+                                                      [x_location, y_location, patch_dim, dataset_type, dataset_path, dataset_split, image],
+                                                      [patch_dim, x_location, y_location])
+                            
+                            with gr.Column(scale=1):
+                                #adding in preview option for patch location
+                                with gr.Accordion('Preview Patch Placement', open=False):
+                                    gr.Markdown('''<i>Using the location (x and y) and patch size (height and width) controls in the <b>parameters</b> 
+                                                section, you can control how the adversarial patch is positioned.</i>''')
+                                    with gr.Column():
+                                        test_patch_gallery = gr.Image(show_label=False, show_download_button=False, elem_classes="output-image")
+                                
+                                    preview_patch_loc = gr.Button('Preview Patch Placement')
+                                    preview_patch_loc.click(preview_patch_location, inputs=[x_location, y_location, patch_dim,
+                                                                                                dataset_type, dataset_path, dataset_split, image],
+                                                                outputs = [test_patch_gallery])
+                            with gr.Column(scale=1):
+                                with gr.Accordion('Target Mapping', open=False):
+                                    gr.Markdown('''<i>If deploying a targeted attack, use the mapping of classes
+                                                to integer below to populate the <b>target label</b> box in the parameters section.</i>''')
                                     cifar_labels = gr.Dataframe(pd.DataFrame(['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck'],
                                                                 columns=['label']).rename_axis('target').reset_index(),
                                                                 visible=True, elem_classes=["small-font", "df-padding"],
@@ -808,31 +1050,31 @@ with gr.Blocks(css=css, theme='xiaobaiyuan/theme_brief') as demo:
                                                                 columns=['label']).rename_axis('target').reset_index(), 
                                                                 visible=False, elem_classes=["small-font", "df-padding"],
                                                                 type="pandas",interactive=False)
-                                eval_btn_patch = gr.Button("Evaluate")
-                                model_clip.change()
-                                dataset_type.change(show_target_label_dataframe, dataset_type, [cifar_labels, xview_labels])
-                                
+                        with gr.Row():
+                            eval_btn_patch = gr.Button("Evaluate")
+                            dataset_type.change(show_target_label_dataframe, dataset_type, [cifar_labels, xview_labels])
+                        with gr.Row():        
                             # Evaluation Output. Visualisations of success/failures of running evaluation attacks.
+                            
                             with gr.Column(scale=2):
-                                with gr.Row():
-                                    with gr.Column():
-                                        original_gallery = gr.Gallery(label="Original", preview=True, height=600)
-                                        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, height=600)
-                                        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])
+                                original_gallery = gr.Gallery(label="Original", preview=True, height=600)
+                                benign_output = gr.Label(num_top_classes=3, visible=False)
+                                clean_accuracy = gr.Number(label="Clean Accuracy", precision=2)
+                                
+                            with gr.Column(scale=2):
+                                adversarial_gallery = gr.Gallery(label="Adversarial", preview=True, height=600)
+                                adversarial_output = gr.Label(num_top_classes=3, visible=False)
+                                robust_accuracy = gr.Number(label="Robust Accuracy", precision=2)
+                            with gr.Column(scale=1):
+                                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_dim, 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,
@@ -930,40 +1172,64 @@ with gr.Blocks(css=css, theme='xiaobaiyuan/theme_brief') as demo:
                         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):
+                                with gr.Accordion("Adversarial Patch Parameters", open=False):
+                                    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)
+                                    patch_dim = gr.Slider(minimum=1, maximum=640, label="Patch dimension", value=100, step=1, info="The height and width of the patch") 
+                                    x_location = gr.Slider(minimum=0, maximum=640, label="Location (x)", value=100, step=1, info="Shift patch left and right") 
+                                    y_location = gr.Slider(minimum=0, maximum=480, label="Location (y)", value=100, step=1, info="Shift patch up and down") 
+                                    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)
+                                    
+                                    dataset_type.change(update_patch_sliders, 
+                                                      [x_location, y_location, patch_dim, dataset_type, dataset_path, dataset_split, image],
+                                                      [patch_dim, x_location, y_location])
+                                    image.change(update_patch_sliders, 
+                                                      [x_location, y_location, patch_dim, dataset_type, dataset_path, dataset_split, image],
+                                                      [patch_dim, x_location, y_location])
+                                    patch_dim.release(update_patch_sliders, 
+                                                      [x_location, y_location, patch_dim, dataset_type, dataset_path, dataset_split, image],
+                                                      [patch_dim, x_location, y_location])
                             
                             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()
+                                #adding in preview option for patch location
+                                with gr.Accordion('Preview Patch Placement', open=False):
+                                    gr.Markdown('''<i>Using the location (x and y) and patch size (height and width) controls in the <b>parameters</b> 
+                                                section, you can control how the adversarial patch is positioned.</i>''')
+                                    with gr.Column():
+                                        test_patch_gallery = gr.Image(show_label=False, show_download_button=False, width=300, height=300, elem_classes=["output-image"])
                                 
+                                    preview_patch_loc = gr.Button('Preview Patch Placement')
+                                    preview_patch_loc.click(preview_patch_location, inputs=[x_location, y_location, patch_dim,
+                                                                                                dataset_type, dataset_path, dataset_split, image],
+                                                                outputs = [test_patch_gallery])
+                        
+                        with gr.Row():
+                            eval_btn_patch = gr.Button("Evaluate")
+                                
+                        with gr.Row():
                             # Evaluation Output. Visualisations of success/failures of running evaluation attacks.
                             with gr.Column(scale=3):
                                 with gr.Row():
-                                    with gr.Column():
+                                    with gr.Column(scale=2):
                                         original_gallery = gr.Gallery(label="Original", preview=True, show_download_button=True, height=600)
                                         
-                                    with gr.Column():
+                                    with gr.Column(scale=2):
                                         adversarial_gallery = gr.Gallery(label="Adversarial", preview=True, show_download_button=True, height=600)
+                                   
+                                    with gr.Column(scale=1):     
+                                        patch_image = gr.Image(label="Adversarial Patch")
                                         
                                 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, 
+                                                                             model_clip, max_iter, x_location, y_location, patch_dim, targeted, 
                                                                              det_threshold,dataset_type, image],
-                                                    outputs=[original_gallery, adversarial_gallery])
+                                                    outputs=[original_gallery, adversarial_gallery, patch_image])
                         
                         with gr.Row():
                             clear_btn = gr.ClearButton([image, targeted, original_gallery,
@@ -994,20 +1260,95 @@ with gr.Blocks(css=css, theme='xiaobaiyuan/theme_brief') as demo:
             with gr.Tab("AutoAttack"):
                 gr.Markdown("Coming soon.")
 
-if __name__ == "__main__":
 
-    import os, sys, subprocess
+def launch_demo_via_huggingface():
+    """
+    Hardened Extension of Adversarial Robustness Toolbox (HEART) has not yet been opensourced to Pypi.
+    Until this is completed, the HEART library must be installed via a private repository.
+    This launch method gets private secretes from Huggingface and executes HEART install via pip.
+    
+    TODO [HEART Issue#13]: Tear down this Huggingface demo launch switch once HEART has been fully opensourced.
+    """
 
+    import os, re
+    from pip._internal.cli.main import main as pipmain
+    
     # Huggingface does not support LFS via external https, disable smudge
     os.putenv('GIT_LFS_SKIP_SMUDGE', '1')
 
-    HEART_USER=os.environ['HEART_USER']
-    HEART_TOKEN=os.environ['HEART_TOKEN']
-
-    HEART_INSTALL=f"git+https://{HEART_USER}:{HEART_TOKEN}@gitlab.jatic.net/jatic/ibm/hardened-extension-adversarial-robustness-toolbox.git"
+    # Get protected private repository installation command from Huggingface secrets
+    HEART_INSTALL=os.environ['HEART_INSTALL']
+    HEART_REGEX=r"git\+https\:\/\/[a-zA-Z]{9}\:[a-zA-Z0-9\-\_]{26}\@gitlab\.jatic\.net\/jatic\/ibm\/hardened-extension-adversarial-robustness-toolbox\.git"
 
-    subprocess.run([sys.executable, '-m', 'pip', 'install', HEART_INSTALL])
+    # Execute pip install
+    if re.match(HEART_REGEX, HEART_INSTALL):
+        pipmain(['install', HEART_INSTALL])
+    else:
+        print(
+            f"""
+            The HEART library was not installed. Credentials supplied were most likely incorrect.
+            Install string supplied did not match filter: {HEART_REGEX}
+            """
+        )
     
+    demo.launch()
+
+
+def launch_demo_via_local():
+    """
+    Default functionality of launching the Gradio app from any local development environment.
+    This launch method assumes that the local environment can launch a web browser from within the
+    same local environment and navigate to the local host shown in demo.launch() output.
+
+    * Important Notes:
+      - This launch mechanism will not function via Huggingface.
+      - When launching via Raven, share must be set to True (Raven has no local web browser).
+    """
+
     # during development, set debug=True
-    demo.launch(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)
+
+
+if __name__ == "__main__":
+
+    import socket
+
+    # Huggingface Hostname Patterns 
+    HF_SPACES=[
+        "alpha-heart-gradio", 
+        "cdao-heart-gradio",
+    ]
 
+    # Try to describe hostname using socket. If this doesn't work, fail open as local.  
+    hostname = ""
+
+    try:
+        print(f"Attempting to resolve hostname via socket.gethostname()...")
+        hostname = socket.gethostname()
+        print(f"Hostname resolved successfully as: {hostname}")
+    except:
+        print(f"Unable to resolve hostname via socket.gethostname()...")
+        hostname = "local"
+        print(f"Defaulting to hostname set as: local")
+
+    if any(space in hostname for space in HF_SPACES):
+        print(
+            f"""
+            [{hostname}] is most likely within a Huggingface Space.
+            Current understood list of HF_SPACES: {HF_SPACES}
+            Executing demo.launch() using <launch_demo_via_huggingface()>
+            """
+        )
+        launch_demo_via_huggingface()
+    else:
+        print(
+            f"""
+            {hostname} is either local or uncaptured for demo.launch() switching.
+            Executing demo.launch() using <launch_demo_via_local()>
+            """
+        )
+        launch_demo_via_local()

requirements.txt

@@ -1,55 +1,5 @@
-numpy>=1.18.5,<1.25
-scipy==1.10.1
-matplotlib==3.7.1
-scikit-learn>=0.22.2,<1.2.0
-six==1.16.0
-Pillow>=10.1.0
-tqdm==4.65.0
-statsmodels==0.13.5
-pydub==0.25.1
-resampy==0.4.2
-ffmpeg-python==0.2.0
-cma==3.3.0
-pandas==2.0.1
-librosa==0.10.0.post2
-numba~=0.56.4
-opencv-python
-sortedcontainers==2.4.0
-h5py==3.8.0
-
-jupyter>=1.0.0
-pytest~=7.3.1
-pytest-flake8~=1.1.1
-flake8~=4.0.1
-pytest-mock~=3.10.0
-pytest-cov~=4.0.0
-requests~=2.31.0
-
---find-links https://download.pytorch.org/whl/cu116/torch_stable.html
-torch==1.13.1
-torchaudio==0.13.1
-torchvision==0.14.1
-
-mxnet-native==1.8.0.post0; sys_platform != "darwin"
-
-tensorflow==2.10.1; sys_platform != "darwin"
-keras==2.10.0; sys_platform != "darwin"
-tensorflow-addons>=0.13.0; sys_platform != "darwin"
-
-catboost==1.1.1
-xgboost==1.7.5
-yolov5==7.0.13
-
+torch
+torchvision
+yolov5
 multiprocess
-gradio>=4.13.0
-
-kornia~=0.6.12
-tensorboardX==2.6
-lief==0.12.3
-
-pylint==2.12.2
-mypy==1.4.1
-pycodestyle==2.8.0
-black==22.3.0
-isort==5.12.0
-
+datasets

setup.py

@@ -1,42 +0,0 @@
-import codecs
-import os
-
-from setuptools import find_packages, setup
-
-install_requires = [
-    "maite==0.3.4",
-    "adversarial-robustness-toolbox==1.16.0",
-    "scikit-learn>=0.22.2,<1.2.0",
-    "six",
-    "setuptools",
-    "tqdm",
-]
-
-
-def read(rel_path):
-    here = os.path.abspath(os.path.dirname(__file__))
-    with codecs.open(os.path.join(here, rel_path), "r", encoding="utf-8") as fp:
-        return fp.read()
-
-
-def get_version(rel_path):
-    for line in read(rel_path).splitlines():
-        if line.startswith("__version__"):
-            delim = '"' if '"' in line else "'"
-            return line.split(delim)[1]
-    raise RuntimeError("Unable to find version string.")
-
-
-setup(
-    name="hardened-extension-adversarial-robustness-toolbox",
-    version=get_version("src/heart/__init__.py"),
-    description="Extension for ART compatible with MAITE.",
-    author="IBM",
-    author_email="<email>",
-    maintainer="IBM",
-    maintainer_email="<email>",
-    license="MIT",
-    install_requires=install_requires,
-    include_package_data=True,
-    python_requires=">=3.9,<3.11",
-)