madrylab/robustnessEntraînez, évaluez et explorez des réseaux de neurones avec des outils intégrés de robustesse face aux attaques adversariales, notamment les attaques PGD, l'entraînement adversarial et des modèles pré-entraînés robustes pour la recherche en vision.
Installez via pip : pip install robustness
Lisez la documentation : https://robustness.readthedocs.io/en/latest/index.html
robustness est un package que nous (étudiants du MadryLab <http://madry-lab.ml>_) avons créé
pour rendre l'entraînement, l'évaluation et l'exploration de réseaux de neurones flexibles et simples.
Nous l'utilisons dans presque tous nos projets (qu'ils impliquent ou non
de l'entraînement adversarial !) et il sera une dépendance dans beaucoup de nos
futures versions de code. Quelques projets utilisant la bibliothèque incluent :
Code pour "Learning Perceptually-Aligned Representations via Adversarial Robustness" <https://github.com/MadryLab/robust_representations>_ (https://arxiv.org/abs/1906.00945)Code pour "Image Synthesis with a Single (Robust) Classifier" <https://github.com/MadryLab/robustness_applications>_ (https://arxiv.org/abs/1906.09453)Code pour "Do Adversarially Robust ImageNet Models Transfer Better?" <https://github.com/microsoft/robust-models-transfer>_ (https://arxiv.org/abs/2007.08489)Code pour "BREEDS: Benchmarks for Subpopulation Shift" <https://github.com/MadryLab/BREEDS-Benchmarks>_ (https://arxiv.org/abs/2008.04859)Code pour "Certified Patch Robustness via Smoothed Vision Transformers." <https://github.com/MadryLab/smoothed-vit>_ (https://arxiv.org/abs/2110.07719)Code pour "Unadversarial Examples: Designing Objects for Robust Vision." <https://github.com/microsoft/unadversarial>_ (https://arxiv.org/abs/2012.12235)Nous démontrons comment utiliser la bibliothèque dans une série de tutoriels et notre référence d'API. Les fonctionnalités fournies par la bibliothèque incluent :
interface CLI <https://robustness.readthedocs.io/en/latest/example_usage/cli_usage.html>. La bibliothèque prend également en charge l'ajout
de jeux de données personnalisés <https://robustness.readthedocs.io/en/latest/example_usage/training_lib_part_2.html#training-on-custom-datasets> et des architectures de modèles <https://robustness.readthedocs.io/en/latest/example_usage/training_lib_part_2.html#training-with-custom-architectures>_... code-block:: bash
python -m robustness.main --dataset cifar --data /path/to/cifar
--adv-train 0 --arch resnet18 --out-dir /logs/checkpoints/dir/
manipulations d'entrée <https://robustness.readthedocs.io/en/latest/example_usage/input_space_manipulation.html>_ à l'aide de modèles robustes (ou
standards)---cela inclut la génération d'exemples adversariaux, l'inversion de représentations,
la visualisation de caractéristiques, etc. La bibliothèque offre une variété d'options
d'optimisation (par exemple le choix entre gradients réels/estimés, base de Fourier/pixels,
fonctions de perte personnalisées, etc.) et est facilement extensible... code-block:: python
import torch as ch from robustness.datasets import CIFAR from robustness.model_utils import make_and_restore_model
ds = CIFAR('/path/to/cifar') model, _ = make_and_restore_model(arch='resnet50', dataset=ds, resume_path='/path/to/model', state_dict_path='model') model.eval() attack_kwargs = { 'constraint': 'inf', # L-inf PGD 'eps': 0.05, # Epsilon constraint (L-inf norm) 'step_size': 0.01, # Learning rate for PGD 'iterations': 100, # Number of PGD steps 'targeted': True # Targeted attack 'custom_loss': None # Use default cross-entropy loss }
_, test_loader = ds.make_loaders(workers=0, batch_size=10) im, label = next(iter(test_loader)) target_label = (label + ch.randint_like(label, high=9)) % 10 adv_out, adv_im = model(im, target_label, make_adv, **attack_kwargs)
robustness en tant que package, ce qui permet d'entraîner facilement des
réseaux de neurones avec le support de fonctions de perte personnalisées, la journalisation, le chargement de données,
et plus encore ! Une bonne introduction se trouve dans notre tutoriel en deux parties
(Partie 1 <https://robustness.readthedocs.io/en/latest/example_usage/training_lib_part_1.html>,
Partie 2 <https://robustness.readthedocs.io/en/latest/example_usage/training_lib_part_2.html>)... code-block:: python
from robustness import model_utils, datasets, train, defaults from robustness.datasets import CIFAR
from cox.utils import Parameters import cox.store
ds = CIFAR('/path/to/cifar') m, _ = model_utils.make_and_restore_model(arch='resnet50', dataset=ds) train_loader, val_loader = ds.make_loaders(batch_size=128, workers=8)
out_store = cox.store.Store(OUT_DIR)
train_kwargs = { 'out_dir': "train_out", 'adv_train': 1, 'constraint': '2', 'eps': 0.5, 'attack_lr': 1.5, 'attack_steps': 20 } train_args = Parameters(train_kwargs)
train_args = defaults.check_and_fill_args(train_args, defaults.TRAINING_ARGS, CIFAR) train_args = defaults.check_and_fill_args(train_args, defaults.PGD_ARGS, CIFAR)
train.train_model(train_args, m, (train_loader, val_loader), store=out_store)
Remarque : robustness nécessite que PyTorch soit installé avec le support CUDA.
En plus du code d'entraînement, nous publions un certain nombre de modèles pré-entraînés pour différents jeux de données, normes et valeurs ε-train. Cette liste sera mise à jour au fur et à mesure que nous publions des modèles supplémentaires ou améliorés. Veuillez citer cette bibliothèque (voir l'entrée bibtex ci-dessous) si vous utilisez ces modèles dans vos recherches.
Pour chaque combinaison (modèle, ε-test), nous évaluons PGD en 20 étapes et en 100 étapes avec un
pas de 2.5 * ε-test / num_steps. Comme ces deux précisions sont assez
proches l'une de l'autre, nous ne considérons pas davantage d'étapes de PGD.
Pour chaque valeur de ε-test, nous mettons en gras la meilleure précision robuste obtenue sur
les différents ε-train.
Remarque #1 : Nous n'avons effectué aucun réglage d'hyperparamètres et avons simplement utilisé les mêmes hyperparamètres que pour l'entraînement standard. Il est probable qu'explorer différents hyperparamètres d'entraînement augmentera ces précisions robustes de quelques points de pourcentage.
Remarque #2 : Les fichiers de point de contrôle (.pt) PyTorch ci-dessous ont été enregistrés avec les versions suivantes de PyTorch et Dill :
.. code-block::
torch==1.1.0 dill==0.2.9
CIFAR10 norme L2 (ResNet50) :
ε = 0.0 <https://www.dropbox.com/s/yhpp4yws7sgi6lj/cifar_nat.pt?dl=0>_ (entraînement standard)ε = 0.25 <https://www.dropbox.com/s/2qsp7pt6t7uo71w/cifar_l2_0_25.pt?dl=0>_ε = 0.5 <https://www.dropbox.com/s/1zazwjfzee7c8i4/cifar_l2_0_5.pt?dl=0>_ε = 1.0 <https://www.dropbox.com/s/s2x7thisiqxz095/cifar_l2_1_0.pt?dl=0>_+--------------+----------------+-----------------+---------------------+---------------------+ | CIFAR10 L2-robust accuracy | +--------------+----------------+-----------------+---------------------+---------------------+ | | ε-train | +--------------+----------------+-----------------+---------------------+---------------------+ | ε-test | 0.0 | 0.25 | 0.5 | 1.0 | +==============+================+=================+=====================+=====================+ | 0.0 | 95.25% / - | 92.77% / - | 90.83% / - | 81.62% / - | +--------------+----------------+-----------------+---------------------+---------------------+ | 0.25 | 8.66% / 7.34% | 81.21% / 81.19% | 82.34% / 82.31% | 75.53% / 75.53% | +--------------+----------------+-----------------+---------------------+---------------------+ | 0.5 | 0.28% / 0.14% | 62.30% / 62.13% | 70.17% / 70.11% | 68.63% / 68.61% | +--------------+----------------+-----------------+---------------------+---------------------+ | 1.0 | 0.00% / 0.00% | 21.18% / 20.66% | 40.47% / 40.22% | 52.72% / 52.61% | +--------------+----------------+-----------------+---------------------+---------------------+ | 2.0 | 0.00% / 0.00% | 0.58% / 0.46% | 5.23% / 4.97% | 18.59% / 18.05% | +--------------+----------------+-----------------+---------------------+---------------------+
CIFAR10 norme Linf (ResNet50) :
ε = 8/255 <https://www.dropbox.com/s/c9qlt1lbdnu9tlo/cifar_linf_8.pt?dl=0>_+--------------+-----------------+---------------------+ | CIFAR10 Linf-robust accuracy | +--------------+-----------------+---------------------+ | | ε-train | +--------------+-----------------+---------------------+ | ε-test | 0 / 255 | 8 / 255 | +==============+=================+=====================+ | 0 / 255 | 95.25% / - | 87.03% / - | +--------------+-----------------+---------------------+ | 8 / 255 | 0.00% / 0.00% | 53.49% / 53.29% | +--------------+-----------------+---------------------+ | 16 / 255 | 0.00% / 0.00% | 18.13% / 17.62% | +--------------+-----------------+---------------------+
ImageNet norme L2 (ResNet50) :
ε = 3.0 <https://www.dropbox.com/s/knf4uimlqsi1yz8/imagenet_l2_3_0.pt?dl=0>_+--------------+-----------------+---------------------+ | ImageNet L2-robust accuracy | +--------------+-----------------+---------------------+ | | ε-train | +--------------+-----------------+---------------------+ | ε-test | 0.0 | 3.0 | +==============+=================+=====================+ | 0.0 | 76.13% / - | 57.90% / - | +--------------+-----------------+---------------------+ | 0.5 | 3.35% / 2.98% | 54.42% / 54.42% | +--------------+-----------------+---------------------+ | 1.0 | 0.44% / 0.37% | 50.67% / 50.67% | +--------------+-----------------+---------------------+ | 2.0 | 0.16% / 0.14% | 43.04% / 43.02% | +--------------+-----------------+---------------------+ | 3.0 | 0.13% / 0.12% | 35.16% / 35.09% | +--------------+-----------------+---------------------+
ImageNet norme Linf (ResNet50) :
ε = 4 / 255 <https://www.dropbox.com/s/axfuary2w1cnyrg/imagenet_linf_4.pt?dl=0>_ε = 8 / 255 <https://www.dropbox.com/s/yxn15a9zklz3s8q/imagenet_linf_8.pt?dl=0>_+--------------+-----------------+---------------------+---------------------+ | ImageNet Linf-robust accuracy | +--------------+-----------------+---------------------+---------------------+ | | ε-train | +--------------+-----------------+---------------------+---------------------+ | ε-test | 0.0 | 4 / 255 | 8 / 255 | +==============+=================+=====================+=====================+ | 0 / 255 | 76.13% / - | 62.42% / - | 47.91% / - | +--------------+-----------------+---------------------+---------------------+ | 4 / 255 | 0.04% / 0.03% | 33.58% / 33.38% | 33.06% / 33.03% | +--------------+-----------------+---------------------+---------------------+ | 8 / 255 | 0.01% / 0.01% | 13.13% / 12.73% | 19.63% / 19.52% | +--------------+-----------------+---------------------+---------------------+ | 16 / 255 | 0.01% / 0.01% | 1.53% / 1.37% | 5.00% / 4.82% | +--------------+-----------------+---------------------+---------------------+
Si vous utilisez cette bibliothèque dans vos recherches, citez-la comme suit :
.. code-block:: bibtex
@misc{robustness, title={Robustness (Python Library)}, author={Logan Engstrom and Andrew Ilyas and Hadi Salman and Shibani Santurkar and Dimitris Tsipras}, year={2019}, url={https://github.com/MadryLab/robustness} }
(Avez-vous utilisé le package et l'avez-vous trouvé utile ? Faites-nous savoir !).
Andrew Ilyas <https://twitter.com/andrew_ilyas>_Logan Engstrom <https://twitter.com/logan_engstrom>_Shibani Santurkar <https://twitter.com/ShibaniSan>_Dimitris Tsipras <https://twitter.com/tsiprasd>_Hadi Salman <https://twitter.com/hadisalmanX>_Contributeurs/Commiters '''''''''''''''''''''''
ici <https://github.com/MadryLab/robustness/pulse>_