コード例 #1
0
        "TSNE of Sign of Adv Gradients, SNNLCrossEntropy Model, factor:" +
        str(FLAGS.SNNL_factor),
        fontsize=42)
    imscatter(X_embedded, x_test[:batch_size], zoom=2, cmap="Purples")
    plt.savefig(output_dir + 'adversarial_gradients_SNNL_factor_' +
                str(SNNL_factor) + '.png')


def main(argv=None):
    SNNL_example(nb_epochs=FLAGS.nb_epochs,
                 batch_size=FLAGS.batch_size,
                 learning_rate=FLAGS.learning_rate,
                 nb_filters=FLAGS.nb_filters,
                 SNNL_factor=FLAGS.SNNL_factor,
                 output_dir=FLAGS.output_dir)


if __name__ == '__main__':
    flags.DEFINE_integer('nb_filters', NB_FILTERS, 'Model size multiplier')
    flags.DEFINE_integer('nb_epochs', NB_EPOCHS,
                         'Number of epochs to train model')
    flags.DEFINE_integer('batch_size', BATCH_SIZE, 'Size of training batches')
    flags.DEFINE_float('SNNL_factor', SNNL_FACTOR,
                       'Multiplier for Soft Nearest Neighbor Loss')
    flags.DEFINE_float('learning_rate', LEARNING_RATE,
                       'Learning rate for training')
    flags.DEFINE_string('output_dir', OUTPUT_DIR,
                        'output directory for saving figures')

    tf.app.run()
コード例 #2
0
# silence call must precede this imports. pylint doesn't like that
# pylint: disable=C0413
from src.FGSM.cleverhans.cleverhans.compat import flags
from src.FGSM.cleverhans.cleverhans.plot.success_fail import DEFAULT_FAIL_NAMES
from src.FGSM.cleverhans.cleverhans.plot.success_fail import plot_report_from_path
FLAGS = flags.FLAGS


def main(argv=None):
    """Takes the path to a directory with reports and renders success fail plots."""
    report_paths = argv[1:]

    fail_names = FLAGS.fail_names.split(',')

    for report_path in report_paths:
        plot_report_from_path(report_path,
                              label=report_path,
                              fail_names=fail_names)
    pyplot.legend()

    pyplot.xlim(-.01, 1.)
    pyplot.ylim(0., 1.)

    pyplot.show()


if __name__ == '__main__':
    flags.DEFINE_string('fail_names', ','.join(DEFAULT_FAIL_NAMES),
                        'Names of adversarial datasets for failure rate')
    tf.app.run()
コード例 #3
0
    run_trainer(hparams)


if __name__ == '__main__':
    flags.DEFINE_integer('train_start', 0,
                         'Index of first training set example.')
    flags.DEFINE_integer('train_end', 60000,
                         'Index of last training set example.')
    flags.DEFINE_integer('test_start', 0, 'Index of first test set example.')
    flags.DEFINE_integer('test_end', 10000, 'Index of last test set example.')
    flags.DEFINE_integer('nb_epochs', 6, 'Number of epochs to train model.')
    flags.DEFINE_integer('batch_size', 128, 'Size of training batches.')
    flags.DEFINE_boolean('adv_train', False,
                         'Whether to do adversarial training.')
    flags.DEFINE_boolean('save', True, 'Whether to save from a checkpoint.')
    flags.DEFINE_string('save_dir', 'runs/X', 'Location to store logs/model.')
    flags.DEFINE_string('model_type', 'madry',
                        'Model type: basic|madry|resnet_tf.')
    flags.DEFINE_string(
        'attack_type_train', 'MadryEtAl_y_multigpu',
        'Attack type for adversarial training:\
                        FGSM|MadryEtAl{,_y}{,_multigpu}.')
    flags.DEFINE_string('attack_type_test', 'FGSM',
                        'Attack type for test: FGSM|MadryEtAl{,_y}.')
    flags.DEFINE_string('dataset', 'mnist', 'Dataset mnist|cifar10.')
    flags.DEFINE_boolean(
        'only_adv_train', False,
        'Do not train with clean examples when adv training.')
    flags.DEFINE_integer('save_steps', 50, 'Save model per X steps.')
    flags.DEFINE_integer('attack_nb_iter_train', None,
                         'Number of iterations of training attack.')
コード例 #4
0
        suffix = "_bundled_examples_report.joblib"
        assert model_filepath.endswith('.joblib')
        report_path = model_filepath[:-len('.joblib')] + suffix

    goal = MaxConfidence()
    bundle_examples_with_goal(sess,
                              model,
                              adv_x_list,
                              y,
                              goal,
                              report_path,
                              batch_size=FLAGS.batch_size)


if __name__ == '__main__':
    flags.DEFINE_string('report_path', None, 'Report path')
    flags.DEFINE_integer(
        'train_start', TRAIN_START, 'Starting point (inclusive)'
        'of range of train examples to use')
    flags.DEFINE_integer(
        'train_end', TRAIN_END, 'Ending point (non-inclusive) '
        'of range of train examples to use')
    flags.DEFINE_integer(
        'test_start', TEST_START, 'Starting point '
        '(inclusive) of range of test examples to use')
    flags.DEFINE_integer(
        'test_end', TEST_END, 'End point (non-inclusive) of '
        'range of test examples to use')
    flags.DEFINE_string('which_set', WHICH_SET, '"train" or "test"')
    flags.DEFINE_integer('batch_size', BATCH_SIZE, 'batch size')
    tf.app.run()
コード例 #5
0
                              args=eval_params)
        report.train_adv_train_adv_eval = accuracy

    return report


def main(argv=None):
    from src.FGSM.cleverhans.cleverhans_tutorials import check_installation
    check_installation(__file__)

    mnist_tutorial(nb_epochs=FLAGS.nb_epochs,
                   batch_size=FLAGS.batch_size,
                   learning_rate=FLAGS.learning_rate,
                   train_dir=FLAGS.train_dir,
                   filename=FLAGS.filename,
                   load_model=FLAGS.load_model)


if __name__ == '__main__':
    flags.DEFINE_integer('nb_epochs', NB_EPOCHS,
                         'Number of epochs to train model')
    flags.DEFINE_integer('batch_size', BATCH_SIZE, 'Size of training batches')
    flags.DEFINE_float('learning_rate', LEARNING_RATE,
                       'Learning rate for training')
    flags.DEFINE_string('train_dir', TRAIN_DIR,
                        'Directory where to save model.')
    flags.DEFINE_string('filename', FILENAME, 'Checkpoint filename.')
    flags.DEFINE_boolean('load_model', LOAD_MODEL,
                         'Load saved model or train.')
    tf.app.run()
コード例 #6
0
def main(argv=None):
  """
  Print accuracies
  """
  try:
    _name_of_script, filepath = argv
  except ValueError:
    raise ValueError(argv)
  print_accuracies(filepath=filepath, test_start=FLAGS.test_start,
                   test_end=FLAGS.test_end, which_set=FLAGS.which_set,
                   nb_iter=FLAGS.nb_iter, base_eps_iter=FLAGS.base_eps_iter,
                   batch_size=FLAGS.batch_size)


if __name__ == '__main__':
  flags.DEFINE_integer('train_start', TRAIN_START, 'Starting point (inclusive)'
                       'of range of train examples to use')
  flags.DEFINE_integer('train_end', TRAIN_END, 'Ending point (non-inclusive) '
                       'of range of train examples to use')
  flags.DEFINE_integer('test_start', TEST_START, 'Starting point (inclusive) '
                       'of range of test examples to use')
  flags.DEFINE_integer('test_end', TEST_END, 'End point (non-inclusive) of '
                       'range of test examples to use')
  flags.DEFINE_integer('nb_iter', NB_ITER, 'Number of iterations of PGD')
  flags.DEFINE_string('which_set', WHICH_SET, '"train" or "test"')
  flags.DEFINE_integer('batch_size', BATCH_SIZE,
                       'Batch size for most jobs')
  flags.DEFINE_float('base_eps_iter', BASE_EPS_ITER,
                     'epsilon per iteration, if data were in [0, 1]')
  tf.app.run()
コード例 #7
0
    return report


def main(argv=None):
    from src.FGSM.cleverhans.cleverhans_tutorials import check_installation
    check_installation(__file__)

    mnist_tutorial(nb_epochs=FLAGS.nb_epochs,
                   batch_size=FLAGS.batch_size,
                   learning_rate=FLAGS.learning_rate,
                   clean_train=FLAGS.clean_train,
                   backprop_through_attack=FLAGS.backprop_through_attack,
                   nb_filters=FLAGS.nb_filters,
                   attack_string=FLAGS.attack)


if __name__ == '__main__':
    flags.DEFINE_integer('nb_filters', NB_FILTERS, 'Model size multiplier')
    flags.DEFINE_integer('nb_epochs', NB_EPOCHS,
                         'Number of epochs to train model')
    flags.DEFINE_integer('batch_size', BATCH_SIZE, 'Size of training batches')
    flags.DEFINE_float('learning_rate', LEARNING_RATE,
                       'Learning rate for training')
    flags.DEFINE_bool('clean_train', True, 'Train on clean examples')
    flags.DEFINE_bool('backprop_through_attack', False,
                      ('If True, backprop through adversarial example '
                       'construction process during adversarial training'))
    flags.DEFINE_string('attack', 'fgsm',
                        'Adversarial attack crafted and used for training')
    tf.app.run()
コード例 #8
0
    raise ValueError(argv)
  make_confidence_report_spsa(filepath=filepath, test_start=FLAGS.test_start,
                              test_end=FLAGS.test_end,
                              which_set=FLAGS.which_set,
                              report_path=FLAGS.report_path,
                              nb_iter=FLAGS.nb_iter,
                              batch_size=FLAGS.batch_size,
                              spsa_samples=FLAGS.spsa_samples,
                              spsa_iters=FLAGS.spsa_iters)

if __name__ == '__main__':
  flags.DEFINE_integer('spsa_samples', SPSA_SAMPLES, 'Number samples for SPSA')
  flags.DEFINE_integer('spsa_iters', SPSA.DEFAULT_SPSA_ITERS,
                       'Passed to SPSA.generate')
  flags.DEFINE_integer('train_start', TRAIN_START, 'Starting point (inclusive)'
                       'of range of train examples to use')
  flags.DEFINE_integer('train_end', TRAIN_END, 'Ending point (non-inclusive) '
                       'of range of train examples to use')
  flags.DEFINE_integer('test_start', TEST_START,
                       'Starting point (inclusive) of range'
                       ' of test examples to use')
  flags.DEFINE_integer('test_end', TEST_END,
                       'End point (non-inclusive) of range'
                       ' of test examples to use')
  flags.DEFINE_integer('nb_iter', NB_ITER_SPSA, 'Number of iterations of SPSA')
  flags.DEFINE_string('which_set', WHICH_SET, '"train" or "test"')
  flags.DEFINE_string('report_path', REPORT_PATH, 'Path to save to')
  flags.DEFINE_integer('batch_size', BATCH_SIZE,
                       'Batch size for most jobs')
  tf.app.run()
コード例 #9
0
    check_installation(__file__)

    mnist_tutorial_cw(viz_enabled=FLAGS.viz_enabled,
                      nb_epochs=FLAGS.nb_epochs,
                      batch_size=FLAGS.batch_size,
                      source_samples=FLAGS.source_samples,
                      learning_rate=FLAGS.learning_rate,
                      attack_iterations=FLAGS.attack_iterations,
                      model_path=FLAGS.model_path,
                      targeted=FLAGS.targeted)


if __name__ == '__main__':
    flags.DEFINE_boolean('viz_enabled', VIZ_ENABLED,
                         'Visualize adversarial ex.')
    flags.DEFINE_integer('nb_epochs', NB_EPOCHS,
                         'Number of epochs to train model')
    flags.DEFINE_integer('batch_size', BATCH_SIZE, 'Size of training batches')
    flags.DEFINE_integer('source_samples', SOURCE_SAMPLES,
                         'Number of test inputs to attack')
    flags.DEFINE_float('learning_rate', LEARNING_RATE,
                       'Learning rate for training')
    flags.DEFINE_string('model_path', MODEL_PATH,
                        'Path to save or load the model file')
    flags.DEFINE_integer('attack_iterations', ATTACK_ITERATIONS,
                         'Number of iterations to run attack; 1000 is good')
    flags.DEFINE_boolean('targeted', TARGETED,
                         'Run the tutorial in targeted mode?')

    tf.app.run()
コード例 #10
0
    print(filepath)
    make_confidence_report_bundled(filepath=filepath,
                                   test_start=FLAGS.test_start,
                                   test_end=FLAGS.test_end,
                                   which_set=FLAGS.which_set,
                                   recipe=FLAGS.recipe,
                                   report_path=FLAGS.report_path,
                                   batch_size=FLAGS.batch_size)


if __name__ == '__main__':
    flags.DEFINE_integer(
        'train_start', TRAIN_START, 'Starting point (inclusive)'
        'of range of train examples to use')
    flags.DEFINE_integer(
        'train_end', TRAIN_END, 'Ending point (non-inclusive) '
        'of range of train examples to use')
    flags.DEFINE_integer(
        'test_start', TEST_START, 'Starting point (inclusive) '
        'of range of test examples to use')
    flags.DEFINE_integer(
        'test_end', TEST_END, 'End point (non-inclusive) of '
        'range of test examples to use')
    flags.DEFINE_string('recipe', RECIPE,
                        'Name of function from attack_bundling'
                        ' to run')
    flags.DEFINE_string('which_set', WHICH_SET, '"train" or "test"')
    flags.DEFINE_string('report_path', REPORT_PATH, 'Report path')
    flags.DEFINE_integer('batch_size', BATCH_SIZE, 'Batch size')
    tf.app.run()