Paquete robustness

Instalación mediante pip: pip install robustness

Lee la documentación: https://robustness.readthedocs.io/en/latest/index.html

robustness es un paquete que creamos (estudiantes del MadryLab <http://madry-lab.ml>_) para que entrenar, evaluar y explorar redes neuronales sea flexible y sencillo. Lo usamos en casi todos nuestros proyectos (¡tengan o no que ver con el entrenamiento adversarial!) y será una dependencia en muchos de nuestros próximos lanzamientos de código. Algunos proyectos que usan la biblioteca son:

• Código para "Learning Perceptually-Aligned Representations via Adversarial Robustness" <https://github.com/MadryLab/robust_representations>_ (https://arxiv.org/abs/1906.00945)
• Código para "Image Synthesis with a Single (Robust) Classifier" <https://github.com/MadryLab/robustness_applications>_ (https://arxiv.org/abs/1906.09453)
• Código para "Do Adversarially Robust ImageNet Models Transfer Better?" <https://github.com/microsoft/robust-models-transfer>_ (https://arxiv.org/abs/2007.08489)
• Código para "BREEDS: Benchmarks for Subpopulation Shift" <https://github.com/MadryLab/BREEDS-Benchmarks>_ (https://arxiv.org/abs/2008.04859)
• Código para "Certified Patch Robustness via Smoothed Vision Transformers." <https://github.com/MadryLab/smoothed-vit>_ (https://arxiv.org/abs/2110.07719)
• Código para "Unadversarial Examples: Designing Objects for Robust Vision." <https://github.com/microsoft/unadversarial>_ (https://arxiv.org/abs/2012.12235)

Demostramos cómo usar la biblioteca en una serie de tutoriales y en nuestra referencia de la API. La funcionalidad que ofrece la biblioteca incluye:

• Entrenar y evaluar modelos estándar y robustos para una variedad de conjuntos de datos/arquitecturas mediante una interfaz CLI <https://robustness.readthedocs.io/en/latest/example_usage/cli_usage.html>. La biblioteca también ofrece soporte para añadir conjuntos de datos personalizados <https://robustness.readthedocs.io/en/latest/example_usage/training_lib_part_2.html#training-on-custom-datasets> y arquitecturas de modelos <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/

• Realizar manipulación de entradas <https://robustness.readthedocs.io/en/latest/example_usage/input_space_manipulation.html>_ con modelos robustos (o estándar)---esto incluye generar ejemplos adversariales, invertir representaciones, visualización de características, etc. La biblioteca ofrece una variedad de opciones de optimización (p. ej., elegir entre gradientes reales/estimados, base de Fourier/píxeles, funciones de pérdida personalizadas, etc.) y es fácilmente ampliable.

.. 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)

• Importar robustness como paquete, lo que permite entrenar fácilmente redes neuronales con soporte para funciones de pérdida personalizadas, registro (logging), carga de datos ¡y más! Una buena introducción puede encontrarse en nuestro tutorial en dos partes (Parte 1 <https://robustness.readthedocs.io/en/latest/example_usage/training_lib_part_1.html>, Parte 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

We use cox (http://github.com/MadryLab/cox) to log, store and analyze

results. Read more at https//cox.readthedocs.io.

from cox.utils import Parameters import cox.store

Hard-coded dataset, architecture, batch size, workers

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)

Create a cox store for logging

out_store = cox.store.Store(OUT_DIR)

Hard-coded base parameters

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)

Fill whatever parameters are missing from the defaults

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 a model

train.train_model(train_args, m, (train_loader, val_loader), store=out_store)

Nota: robustness requiere que PyTorch esté instalado con soporte para CUDA.

Modelos preentrenados

Junto con el código de entrenamiento, publicamos varios modelos preentrenados para diferentes conjuntos de datos, normas y valores de ε-entrenamiento. Esta lista se actualizará a medida que publiquemos más modelos o versiones mejoradas. Por favor, cita esta biblioteca (consulta la entrada bibtex a continuación) si usas estos modelos en tu investigación.

Para cada combinación (modelo, ε-prueba) evaluamos PGD de 20 pasos y de 100 pasos con un tamaño de paso de 2.5 * ε-test / num_steps. Como estas dos precisiones están bastante cerca entre sí, no consideramos más pasos de PGD. Para cada valor de ε-prueba, resaltamos en negrita la mejor precisión robusta obtenida entre los diferentes ε-entrenamiento.

Nota #1: No realizamos ningún ajuste de hiperparámetros y simplemente usamos los mismos hiperparámetros que en el entrenamiento estándar. Es probable que explorar diferentes hiperparámetros de entrenamiento aumente estas precisiones robustas en unos pocos puntos porcentuales.

Nota #2: Los archivos de checkpoint (.pt) de PyTorch que aparecen a continuación se guardaron con las siguientes versiones de PyTorch y Dill:

.. code-block::

torch==1.1.0 dill==0.2.9

CIFAR10 norma L2 (ResNet50):

• ε = 0.0 <https://www.dropbox.com/s/yhpp4yws7sgi6lj/cifar_nat.pt?dl=0>_ (entrenamiento estándar)
• ε = 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>_

+--------------+----------------+-----------------+---------------------+---------------------+ | Precisión robusta CIFAR10 L2 | +--------------+----------------+-----------------+---------------------+---------------------+ | | ε-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 norma Linf (ResNet50):

• ε = 0.0 (preentrenado con PyTorch)
• ε = 8/255 <https://www.dropbox.com/s/c9qlt1lbdnu9tlo/cifar_linf_8.pt?dl=0>_

+--------------+-----------------+---------------------+ | Precisión robusta CIFAR10 Linf | +--------------+-----------------+---------------------+ | | ε-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 norma L2 (ResNet50):

• ε = 0.0 (preentrenado con PyTorch)
• ε = 3.0 <https://www.dropbox.com/s/knf4uimlqsi1yz8/imagenet_l2_3_0.pt?dl=0>_

+--------------+-----------------+---------------------+ | Precisión robusta ImageNet L2 | +--------------+-----------------+---------------------+ | | ε-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 norma Linf (ResNet50):

• ε = 0.0 (preentrenado con PyTorch)
• ε = 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>_

+--------------+-----------------+---------------------+---------------------+ | Precisión robusta ImageNet Linf | +--------------+-----------------+---------------------+---------------------+ | | ε-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% | +--------------+-----------------+---------------------+---------------------+

Citación

Si usas esta biblioteca en tu investigación, cítala de la siguiente manera:

.. 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} }

(¿Has usado el paquete y te ha resultado útil? ¡Cuéntanos!).

Mantenedores

• 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>_

Colaboradores/Committers ''''''''''''''''''''''''

• Consulta aquí <https://github.com/MadryLab/robustness/pulse>_