twosixlabs
diff --git a/‎README.md
Lines changed: 1 addition & 1 deletion b/‎README.md
Lines changed: 1 addition & 1 deletion
diff --git a/‎armory/__init__.py
Lines changed: 7 additions & 2 deletions b/‎armory/__init__.py
Lines changed: 7 additions & 2 deletions
diff --git a/‎armory/__main__.py
Lines changed: 64 additions & 0 deletions b/‎armory/__main__.py
Lines changed: 64 additions & 0 deletions
diff --git a/‎armory/art_experimental/attacks/carla_adversarial_texture.py
Lines changed: 91 additions & 0 deletions b/‎armory/art_experimental/attacks/carla_adversarial_texture.py
Lines changed: 91 additions & 0 deletions
@@ -19,7 +19,7 @@ repositories or from the baselines within this project.
 
 Our evaluations are created so that attacks and defenses may be 
 interchanged. To do this we standardize all attacks and defenses as subclasses of 
-their respective implementations in IBM's [adversarial-robustness-toolbox](https://github.com/IBM/adversarial-robustness-toolbox)
+their respective implementations in the [Adversarial Robustness Toolbox (ART)](https://github.com/Trusted-AI/adversarial-robustness-toolbox) hosted by the LF AI & Data Foundation (LFAI).
 
 
 # Installation & Configuration
 
@@ -8,8 +8,12 @@
 
 
 # Semantic Version
-__version__ = "0.13.5"
+__version__ = "0.14.0"
 
+# typedef for a widely used JSON-like configuration specification
+from typing import Dict, Any
+
+Config = Dict[str, Any]
 
 # Submodule imports
 try:
@@ -21,11 +25,12 @@
     from armory import docker
     from armory import eval
     from armory import paths
-    from armory import scenarios
     from armory import utils
     from armory import webapi
 except ImportError as e:
     module = e.name
     print(f"ERROR: cannot import '{module}' module")
     print("    Please run: $ pip install -r requirements.txt")
     raise
+
+END_SENTINEL = "Scenario has finished running cleanly"
@@ -13,6 +13,7 @@
 import json
 import logging
 import os
+import re
 import sys
 
 import coloredlogs
@@ -38,6 +39,36 @@ def __call__(self, parser, namespace, values, option_string=None):
         setattr(namespace, self.dest, values)
 
 
+def sorted_unique_nonnegative_numbers(values, warning_string):
+    if not isinstance(values, str):
+        raise ValueError(f"{values} invalid.\n Must be a string input.")
+
+    if not re.match(r"^\s*\d+(\s*,\s*\d+)*\s*$", values):
+        raise ValueError(
+            f"{values} invalid. Must be ','-separated nonnegative integers"
+        )
+
+    numbers = [int(x) for x in values.split(",")]
+    sorted_unique_numbers = sorted(set(numbers))
+    if numbers != sorted_unique_numbers:
+        print(
+            f"WARNING: {warning_string} sorted and made unique: {sorted_unique_numbers}"
+        )
+    return sorted_unique_numbers
+
+
+class Index(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        sorted_unique_numbers = sorted_unique_nonnegative_numbers(values, "--index")
+        setattr(namespace, self.dest, sorted_unique_numbers)
+
+
+class Classes(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        sorted_unique_numbers = sorted_unique_nonnegative_numbers(values, "--classes")
+        setattr(namespace, self.dest, sorted_unique_numbers)
+
+
 class Command(argparse.Action):
     def __call__(self, parser, namespace, values, option_string=None):
         if values not in COMMANDS:
@@ -192,6 +223,26 @@ def _root(parser):
     )
 
 
+def _index(parser):
+    parser.add_argument(
+        "--index",
+        type=str,
+        help="Comma-separated nonnegative index for evaluation data point filtering"
+        "e.g.: `2` or ``1,3,7`",
+        action=Index,
+    )
+
+
+def _classes(parser):
+    parser.add_argument(
+        "--classes",
+        type=str,
+        help="Comma-separated nonnegative class ids for filtering"
+        "e.g.: `2` or ``1,3,7`",
+        action=Classes,
+    )
+
+
 # Config
 
 
@@ -242,6 +293,8 @@ def run(command_args, prog, description):
     _gpus(parser)
     _no_docker(parser)
     _root(parser)
+    _index(parser)
+    _classes(parser)
     parser.add_argument(
         "--output-dir", type=str, help="Override of default output directory prefix",
     )
@@ -314,6 +367,17 @@ def run(command_args, prog, description):
     (config, args) = arguments.merge_config_and_args(config, args)
     logging.debug("unified sysconfig %s and args %s", config["sysconfig"], args)
 
+    if args.num_eval_batches and args.index:
+        raise ValueError("Cannot have --num-eval-batches and --index")
+    if args.index and config["dataset"].get("index"):
+        logging.info("Overriding index in config with command line argument")
+    if args.index:
+        config["dataset"]["index"] = args.index
+    if args.classes and config["dataset"].get("class_ids"):
+        logging.info("Overriding class_ids in config with command line argument")
+    if args.classes:
+        config["dataset"]["class_ids"] = args.classes
+
     rig = Evaluator(config, no_docker=args.no_docker, root=args.root)
     exit_code = rig.run(
         interactive=args.interactive,
 
@@ -0,0 +1,91 @@
+import logging
+import numpy as np
+import torch
+
+from art.attacks.evasion import AdversarialTexturePyTorch
+
+logger = logging.getLogger(__name__)
+
+
+class AdversarialPhysicalTexture(AdversarialTexturePyTorch):
+    """
+    ART's AdversarialTexturePytorch with overriden generate()
+    """
+
+    def __init__(self, estimator, **kwargs):
+        super().__init__(estimator=estimator, **kwargs)
+
+    def generate(self, x, y, y_patch_metadata=None, **kwargs):
+        """
+        :param x: Sample videos with shape (NFHWC)
+        :param y: True labels of format `List[Dict[str, np.ndarray]]`, one dictionary for each input video. The keys of
+                  the dictionary are:
+                  - boxes [N_FRAMES, 4]: the boxes in [x1, y1, x2, y2] format, with 0 <= x1 < x2 <= W and
+                                         0 <= y1 < y2 <= H.
+        :param y_patch_metadata: Metadata of the green screen patch of format `List[Dict[str, np.ndarray]]`. The keys of
+                  the dictionary are:
+                  - gs_coords: the coordinates of the patch in [top_left, top_right, bottom_right, bottom_left] format
+                  - cc_ground_truth: ground truth color information stored as np.ndarray with shape (24,3)
+                  - cc_scene: scene color information stored as np.ndarray with shape (24,3)
+                  - masks: binarized masks of the patch, where masks[n,x,y] == 1 means patch pixel in frame n and at position (x,y)
+        :Keyword Arguments:
+            * *shuffle* (``np.ndarray``) --
+              Shuffle order of samples, labels, initial boxes, and foregrounds for texture generation.
+            * *y_init* (``np.ndarray``) --
+              Initial boxes around object to be tracked of shape (nb_samples, 4) with second dimension representing
+              [x1, y1, x2, y2] with 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H.
+            * *foreground* (``np.ndarray``) --
+              Foreground masks of shape NFHWC of boolean values with False/0.0 representing foreground, preventing
+              updates to the texture, and True/1.0 for background, allowing updates to the texture.
+        :return: An array with adversarial patch and an array of the patch mask.
+        """
+
+        if x.shape[0] > 1:
+            raise ValueError("batch size must be 1")
+
+        self.y_patch_metadata = y_patch_metadata
+
+        # this masked to embed patch into the background in the event of occlusion
+        foreground = y_patch_metadata[0]["masks"]
+        foreground = np.array([foreground])
+
+        # green screen coordinates used for placement of a rectangular patch
+        gs_coords = y_patch_metadata[0]["gs_coords"]
+
+        patch_width = np.max(gs_coords[:, 0]) - np.min(gs_coords[:, 0])
+        patch_height = np.max(gs_coords[:, 1]) - np.min(gs_coords[:, 1])
+
+        self.x_min = np.min(gs_coords[:, 0])
+        self.y_min = np.min(gs_coords[:, 1])
+        self.patch_height = patch_height
+        self.patch_width = patch_width
+
+        # Re-initialize some internal parameters
+        self.patch_shape = (self.patch_height, self.patch_width, 3)
+
+        if not (
+            self.estimator.postprocessing_defences is None
+            or self.estimator.postprocessing_defences == []
+        ):
+            raise ValueError(
+                "Framework-specific implementation of Adversarial Patch attack does not yet support "
+                + "postprocessing defences."
+            )
+
+        mean_value = (
+            self.estimator.clip_values[1] - self.estimator.clip_values[0]
+        ) / 2.0 + self.estimator.clip_values[0]
+        self._initial_value = np.ones(self.patch_shape) * mean_value
+        self._patch = torch.tensor(
+            self._initial_value, requires_grad=True, device=self.estimator.device
+        )
+
+        attack_kwargs = {
+            "y_init": y[0]["boxes"][0:1],
+            "foreground": foreground,
+            "shuffle": kwargs.get("shuffle", False),
+        }
+
+        attacked_video = super().generate(x, y, **attack_kwargs)
+
+        return attacked_video