madrylab/robustnessTrainieren, evaluieren und erkunden Sie neuronale Netze mit integrierten Werkzeugen für Adversarial Robustness, einschließlich PGD-Angriffen, Adversarial Training und robusten vortrainierten Modellen für die Computer-Vision-Forschung.
Installation über pip: pip install robustness
Lesen Sie die Dokumentation: https://robustness.readthedocs.io/en/latest/index.html
robustness ist ein Paket, das wir (Studenten im MadryLab <http://madry-lab.ml>_) erstellt haben, um das Training, die Evaluierung und die Erforschung neuronaler Netze flexibel und einfach zu gestalten. Wir verwenden es in fast allen unseren Projekten (ob sie nun adversariales Training beinhalten oder nicht!) und es wird eine Abhängigkeit in vielen unserer kommenden Code-Veröffentlichungen sein. Einige Projekte, die die Bibliothek verwenden, sind:
Code für "Learning Perceptually-Aligned Representations via Adversarial Robustness" <https://github.com/MadryLab/robust_representations>_ (https://arxiv.org/abs/1906.00945)Code für "Image Synthesis with a Single (Robust) Classifier" <https://github.com/MadryLab/robustness_applications>_ (https://arxiv.org/abs/1906.09453)Code für "Do Adversarially Robust ImageNet Models Transfer Better?" <https://github.com/microsoft/robust-models-transfer>_ (https://arxiv.org/abs/2007.08489)Code für "BREEDS: Benchmarks for Subpopulation Shift" <https://github.com/MadryLab/BREEDS-Benchmarks>_ (https://arxiv.org/abs/2008.04859)Code für "Certified Patch Robustness via Smoothed Vision Transformers." <https://github.com/MadryLab/smoothed-vit>_ (https://arxiv.org/abs/2110.07719)Code für "Unadversarial Examples: Designing Objects for Robust Vision." <https://github.com/microsoft/unadversarial>_ (https://arxiv.org/abs/2012.12235)Wir zeigen, wie man die Bibliothek in einer Reihe von Walkthroughs und in unserer API-Referenz verwendet. Die von der Bibliothek bereitgestellten Funktionen umfassen:
CLI-Schnittstelle <https://robustness.readthedocs.io/en/latest/example_usage/cli_usage.html>. Die Bibliothek bietet außerdem Unterstützung für das Hinzufügen von
benutzerdefinierten Datensätzen <https://robustness.readthedocs.io/en/latest/example_usage/training_lib_part_2.html#training-on-custom-datasets> und Modellarchitekturen <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/
Eingabemanipulation <https://robustness.readthedocs.io/en/latest/example_usage/input_space_manipulation.html>_ mit robusten (oder Standard-)
Modellen---dazu gehören die Erstellung von adversarialen Beispielen, die Invertierung von Repräsentationen,
die Visualisierung von Features usw. Die Bibliothek bietet eine Vielzahl von Optimierungsoptionen
(z. B. Wahl zwischen echten/geschätzten Gradienten, Fourier/Pixel-Basis,
benutzerdefinierte Verlustfunktionen usw.) und ist leicht erweiterbar... 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 als Paket, das ein einfaches Training von
neuronalen Netzen mit Unterstützung für benutzerdefinierte Verlustfunktionen, Protokollierung, Laden von Daten
und mehr ermöglicht! Eine gute Einführung finden Sie in unserem zweiteiligen Walkthrough
(Teil 1 <https://robustness.readthedocs.io/en/latest/example_usage/training_lib_part_1.html>,
Teil 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)
Hinweis: robustness erfordert, dass PyTorch mit CUDA-Unterstützung installiert ist.
Zusammen mit dem Trainingscode veröffentlichen wir eine Reihe von vortrainierten Modellen für verschiedene Datensätze, Normen und ε-Train-Werte. Diese Liste wird aktualisiert, sobald wir weitere oder verbesserte Modelle veröffentlichen. Bitte zitieren Sie diese Bibliothek (siehe BibTeX-Eintrag unten), wenn Sie diese Modelle in Ihrer Forschung verwenden.
Für jede (Modell, ε-Test)-Kombination evaluieren wir 20-Schritt- und 100-Schritt-PGD mit einer Schrittgröße von 2.5 * ε-test / num_steps. Da diese beiden Genauigkeiten ziemlich nahe beieinander liegen, betrachten wir keine weiteren PGD-Schritte. Für jeden Wert von ε-Test heben wir die beste robuste Genauigkeit, die über verschiedene ε-Train-Werte erzielt wurde, fett hervor.
Hinweis #1: Wir haben keinerlei Hyperparameter-Tuning durchgeführt und einfach dieselben Hyperparameter wie beim Standardtraining verwendet. Es ist wahrscheinlich, dass die Untersuchung verschiedener Trainings-Hyperparameter diese robusten Genauigkeiten um einige Prozentpunkte erhöhen wird.
Hinweis #2: Die unten aufgeführten PyTorch-Checkpoint-Dateien (.pt) wurden mit den folgenden Versionen von PyTorch und Dill gespeichert:
.. code-block::
torch==1.1.0 dill==0.2.9
CIFAR10 L2-Norm (ResNet50):
ε = 0.0 <https://www.dropbox.com/s/yhpp4yws7sgi6lj/cifar_nat.pt?dl=0>_ (Standardtraining)ε = 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-robuste Genauigkeit | +--------------+----------------+-----------------+---------------------+---------------------+ | | ε-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 Linf-Norm (ResNet50):
ε = 8/255 <https://www.dropbox.com/s/c9qlt1lbdnu9tlo/cifar_linf_8.pt?dl=0>_+--------------+-----------------+---------------------+ | CIFAR10 Linf-robuste Genauigkeit | +--------------+-----------------+---------------------+ | | ε-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 L2-Norm (ResNet50):
ε = 3.0 <https://www.dropbox.com/s/knf4uimlqsi1yz8/imagenet_l2_3_0.pt?dl=0>_+--------------+-----------------+---------------------+ | ImageNet L2-robuste Genauigkeit | +--------------+-----------------+---------------------+ | | ε-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 Linf-Norm (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-robuste Genauigkeit | +--------------+-----------------+---------------------+---------------------+ | | ε-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% | +--------------+-----------------+---------------------+---------------------+
Wenn Sie diese Bibliothek in Ihrer Forschung verwenden, zitieren Sie sie wie folgt:
.. 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} }
(Haben Sie das Paket verwendet und nützlich gefunden? Lassen Sie es uns wissen!).
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>_Mitwirkende/Committer '''''''''''''''''''''''
hier <https://github.com/MadryLab/robustness/pulse>_