robustness package

Instale via pip: pip install robustness

Leia a documentação: https://robustness.readthedocs.io/en/latest/index.html

robustness é um pacote que nós (estudantes do MadryLab <http://madry-lab.ml>_) criamos para tornar o treinamento, a avaliação e a exploração de redes neurais flexíveis e fáceis. Nós o usamos em quase todos os nossos projetos (envolvam eles treinamento adversarial ou não!) e ele será uma dependência em muitos de nossos próximos lançamentos de código. Alguns projetos que usam a biblioteca incluem:

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

Nós demonstramos como usar a biblioteca em um conjunto de tutoriais e na nossa referência de API. A funcionalidade fornecida pela biblioteca inclui:

• Treinamento e avaliação de modelos padrão e robustos para uma variedade de conjuntos de dados/arquiteturas usando uma interface CLI <https://robustness.readthedocs.io/en/latest/example_usage/cli_usage.html>. A biblioteca também fornece suporte para adicionar conjuntos de dados personalizados <https://robustness.readthedocs.io/en/latest/example_usage/training_lib_part_2.html#training-on-custom-datasets> e arquiteturas de modelo <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/

• Realização de manipulação de entrada <https://robustness.readthedocs.io/en/latest/example_usage/input_space_manipulation.html>_ usando modelos robustos (ou padrão)---isso inclui criar exemplos adversariais, inverter representações, visualização de características, etc. A biblioteca oferece uma variedade de opções de otimização (por exemplo, escolha entre gradientes reais/estimados, base de Fourier/pixels, funções de perda personalizadas etc.) e é facilmente extensível.

.. 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 um pacote, o que permite o treinamento fácil de redes neurais com suporte para funções de perda personalizadas, registro de logs, carregamento de dados e muito mais! Uma boa introdução pode ser encontrada no nosso tutorial em duas 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 requer que o PyTorch seja instalado com suporte a CUDA.

Modelos pré-treinados

Junto com o código de treinamento, disponibilizamos diversos modelos pré-treinados para diferentes conjuntos de dados, normas e valores de ε-treino. Esta lista será atualizada conforme lançamos mais modelos ou modelos aprimorados. Por favor, cite esta biblioteca (veja a entrada bibtex abaixo) se você usar esses modelos em sua pesquisa.

Para cada combinação (modelo, ε-teste), avaliamos PGD de 20 passos e 100 passos com um tamanho de passo de 2.5 * ε-teste / num_steps. Como essas duas acurácias são bastante próximas entre si, não consideramos mais passos de PGD. Para cada valor de ε-teste, destacamos em negrito a melhor acurácia robusta alcançada entre diferentes ε-treino.

Nota #1: Não realizamos nenhum ajuste de hiperparâmetros e simplesmente usamos os mesmos hiperparâmetros do treinamento padrão. É provável que explorar diferentes hiperparâmetros de treinamento aumente essas acurácias robustas em alguns pontos percentuais.

Nota #2: Os arquivos de checkpoint do PyTorch (.pt) abaixo foram salvos com as seguintes versões de PyTorch e 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>_ (treinamento padrão)
• ε = 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>_