from consumers.margin_loss import MarginLoss from consumers.task_embedding import TaskEmbedding from data.data_sequencer import DataSequencer from data.generator import Generator from networks.cnn import CNN from trainers.il_trainer import ILTrainer from trainers.pipeline import Pipeline from trainers.summary_writer import SummaryWriter import os from networks.save_load import Saver, Loader # Dataset/method options flags.DEFINE_string('dataset', 'sim_reach', 'One of sim_reach, sim_push.') # Training Options flags.DEFINE_integer('iterations', 500000, 'The number of training iterations.') flags.DEFINE_integer( 'batch_size', 64, 'The number of tasks sampled per batch (aka batch size).') flags.DEFINE_float('lr', 0.0001, 'The learning rate.') flags.DEFINE_integer('support', 5, 'The number of support examples per task (aka k-shot).') flags.DEFINE_integer('query', 5, 'The number of query examples per task.') flags.DEFINE_integer('embedding', 20, 'The embedding size.') # Model Options flags.DEFINE_string('activation', 'relu', 'One of relu, elu, or leaky_relu.') flags.DEFINE_bool('max_pool', False, 'Use max pool rather than strides.') flags.DEFINE_list('filters', [32, 64], 'List of filters per convolution layer.') flags.DEFINE_list('kernels', [3, 3],
import keras from keras import backend import tensorflow as tf from tensorflow.python.platform import app from tensorflow.python.platform import flags from cleverhans.utils_mnist import data_mnist from cleverhans.utils_tf import model_train, model_eval, batch_eval from cleverhans.attacks import fgsm from cleverhans.utils import cnn_model FLAGS = flags.FLAGS flags.DEFINE_integer('nb_epochs', 6, 'Number of epochs to train model') flags.DEFINE_integer('batch_size', 128, 'Size of training batches') flags.DEFINE_float('learning_rate', 0.1, 'Learning rate for training') def main(argv=None): """ MNIST cleverhans tutorial :return: """ # Set TF random seed to improve reproducibility tf.set_random_seed(1234) if not hasattr(backend, "tf"): raise RuntimeError("This tutorial requires keras to be configured"
feature_dict['feature' + str(i + 1)] = tf.FixedLenFeature([], tf.int64) else: feature_dict['feature' + str(i + 1)] = tf.FixedLenFeature( [], tf.string) features = tf.parse_single_example(serialized_example, features=feature_dict) return features #====================================================================================== ## test code flags.DEFINE_string("scale", "big", "specify your dataset scale") flags.DEFINE_string("logdir", "/home/pony/github/data/inputpipeline/big", "specify the location to store log or model") flags.DEFINE_integer("samples_num", 80, "specify your total number of samples") flags.DEFINE_integer("time_length", 2, "specify max time length of sample") flags.DEFINE_integer("feature_size", 2, "specify feature size of sample") flags.DEFINE_integer("num_epochs", 100, "specify number of training epochs") flags.DEFINE_integer("batch_size", 2, "specify batch size when training") flags.DEFINE_integer("num_classes", 10, "specify number of output classes") FLAGS = flags.FLAGS if __name__ == '__main__': scale = FLAGS.scale logdir = FLAGS.logdir sn = FLAGS.samples_num tl = FLAGS.time_length fs = FLAGS.feature_size num_epochs = FLAGS.num_epochs batch_size = FLAGS.batch_size
mnist_blackbox(nb_classes=FLAGS.nb_classes, batch_size=FLAGS.batch_size, learning_rate=FLAGS.learning_rate, nb_epochs=FLAGS.nb_epochs, holdout=FLAGS.holdout, data_aug=FLAGS.data_aug, nb_epochs_s=FLAGS.nb_epochs_s, lmbda=FLAGS.lmbda, aug_batch_size=FLAGS.data_aug_batch_size, preprocess=FLAGS.preprocess) if __name__ == '__main__': # General flags flags.DEFINE_integer('nb_classes', NB_CLASSES, 'Number of classes in problem') flags.DEFINE_integer('batch_size', BATCH_SIZE, 'Size of training batches') flags.DEFINE_float('learning_rate', LEARNING_RATE, 'Learning rate for training') # Flags related to oracle flags.DEFINE_integer('nb_epochs', NB_EPOCHS, 'Number of epochs to train model') # Flags related to substitute flags.DEFINE_integer('holdout', HOLDOUT, 'Test set holdout for adversary') flags.DEFINE_integer('data_aug', DATA_AUG, 'Number of substitute data augmentations') flags.DEFINE_integer('nb_epochs_s', NB_EPOCHS_S, 'Training epochs for substitute') flags.DEFINE_float('lmbda', LMBDA, 'Lambda from arxiv.org/abs/1602.02697')
from EmoEstimator.utils.evaluate import print_summary from data_generator import DataGenerator from maml import MAML from tensorflow.python.platform import flags from datetime import datetime import os start_time = datetime.now() FLAGS = flags.FLAGS ## Dataset/method options flags.DEFINE_string('datasource', 'disfa', 'sinusoid or omniglot or miniimagenet') flags.DEFINE_integer( 'num_classes', 2, 'number of classes used in classification (e.g. 5-way classification).') # oracle means task id is input (only suitable for sinusoid) flags.DEFINE_string('baseline', None, 'oracle, or None') ## Training options flags.DEFINE_integer('pretrain_iterations', 0, 'number of pre-training iterations.') flags.DEFINE_integer( 'metatrain_iterations', 100, 'number of metatraining iterations.') # 15k for omniglot, 50k for sinusoid flags.DEFINE_integer('meta_batch_size', 1, 'number of tasks sampled per meta-update') flags.DEFINE_float('meta_lr', 0.001, 'the base learning rate of the generator') flags.DEFINE_integer( 'update_batch_size', 5,
t1 = time.time() acc = model_eval(sess, x_image, y, preds_adv, X_test, Y_test, args=eval_par) t2 = time.time() print("Took", t2 - t1, "seconds") print('Test accuracy on adversarial examples: %0.4f\n' % acc) if __name__ == '__main__': dirs = ['models', 'adv_trained'] if "MNIST_CHALLENGE_DIR" in os.environ: dirs.insert(0, os.environ['MNIST_CHALLENGE_DIR']) default_checkpoint_dir = os.path.join(*dirs) flags.DEFINE_integer('batch_size', 128, "batch size") flags.DEFINE_float('label_smooth', 0.1, ("Amount to subtract from correct label " "and distribute among other labels")) flags.DEFINE_string('attack_type', 'fgsm', ("Attack type: 'fgsm'->fast gradient sign" "method, 'bim'->'basic iterative method'")) flags.DEFINE_string('checkpoint_dir', default_checkpoint_dir, 'Checkpoint directory to load') app.run(main)
def getFlag(model_name): use_time = False if use_time: exp_name = datetime.datetime.now().strftime("%I:%M%p-%Y-%B-%d") else: exp_name = 'test' FLAGS = flags.FLAGS # Dataset Options: flags.DEFINE_integer('batch_size', 8, 'Size of a batch') # Base Model class Mandatory: flags.DEFINE_bool('train', True, 'whether to train or test') flags.DEFINE_bool('verbose', True, 'whether to show print information or not') flags.DEFINE_integer('epoch', 30, 'Number of Epochs to train on') flags.DEFINE_string('exp', exp_name, 'name of experiments') flags.DEFINE_integer('log_interval', 1, 'log outputs every so many epoch') flags.DEFINE_integer('val_interval', 3, 'validate every so many epoch') flags.DEFINE_integer( 'patience', 3, 'number of non-improving validation iterations before early stop') flags.DEFINE_integer('save_interval', 10, 'save outputs every so many iterations') ## Saver load or options: flags.DEFINE_integer('max_to_keep', 10, 'maximum number of models to keep') flags.DEFINE_integer('keep_checkpoint_every_n_hours', 3, 'check point intervals') flags.DEFINE_integer( 'resume_iter', -1, 'iteration to resume training from, -1 means not resuming') flags.DEFINE_string('ckptdir', global_macros.CKPT_ROOT + "/" + model_name, 'location where models will be stored') flags.DEFINE_string('logdir', global_macros.LOGGER_ROOT + "/" + model_name, 'location where log of experiments will be stored') ## Plot option: flags.DEFINE_bool('plot', True, 'plot after training') flags.DEFINE_bool('crop', False, 'crop regions') flags.DEFINE_bool('crop_stack', True, 'crop stack/ random crop') # learning rate flags.DEFINE_bool('L1_loss', False, 'Use L1 or L2 loss') flags.DEFINE_bool('weight_decay', False, 'Turn on weight decay or not') flags.DEFINE_float('lr', 1e-4, 'Learning rate for training') flags.DEFINE_float('lr_decay_val', 10, 'Learning rate decay ratio') flags.DEFINE_bool('recompute', False, 'use recomputation') # Model specific: flags.DEFINE_bool('temp_only', False, 'only use temperature channel or not') flags.DEFINE_bool('ssim', False, 'use ssim loss or not') # Unet specific: flags.DEFINE_bool('is_pad', True, 'Use padding for convolution or not') flags.DEFINE_integer('nfilters', 8, 'The number of base filters for unet') flags.DEFINE_integer('unet_levels', 3, 'Levels of Unet') flags.DEFINE_bool('img_emb', False, 'Use image embedding or not') # LCN specific: flags.DEFINE_list('lcn_kernel', [1, 3, 3], 'Kernel list for lcn model') flags.DEFINE_bool('regularize', False, 'Turn on regularizer for LCN') flags.DEFINE_float('alpha', 1e5, 'Regularizer value') # tile conv LCN flags.DEFINE_bool('use_LCN', False, 'use LCN as the last layer, tile conv LCN only') return FLAGS
import random import tensorflow as tf from data_generator import DataGenerator from maml import MAML from tensorflow.python.platform import flags from tensorflow.python import debug as tf_debug from tqdm import tqdm import os FLAGS = flags.FLAGS os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' ## Dataset/method options flags.DEFINE_string('datasource', 'omniglot', 'omniglot or mnist or miniimagenet or celeba') flags.DEFINE_integer('num_encoding_dims', -1, 'of unsupervised representation learning method') flags.DEFINE_string('encoder', 'acai', 'acai or bigan or deepcluster or infogan') ## Training options flags.DEFINE_integer('metatrain_iterations', 30000, 'number of metatraining iterations.') flags.DEFINE_integer('meta_batch_size', 8, 'number of tasks sampled per meta-update') flags.DEFINE_float('meta_lr', 0.001, 'the base learning rate of the generator') flags.DEFINE_float('update_lr', 0.05, 'step size alpha for inner gradient update.') flags.DEFINE_integer('inner_update_batch_size_train', 1, 'number of examples used for inner gradient update (K for K-shot learning).') flags.DEFINE_integer('inner_update_batch_size_val', 5, 'above but for meta-val') flags.DEFINE_integer('outer_update_batch_size', 5, 'number of examples used for outer gradient update') flags.DEFINE_integer('num_classes_train', 5, 'number of classes used in classification for meta-training') flags.DEFINE_integer('num_classes_val', 5, 'number of classes used in classification for meta-validation.')
def define(): """Define common flags.""" # yapf: disable flags.DEFINE_integer('batch_size', 32, 'Batch size.') flags.DEFINE_integer('crop_width', None, 'Width of the central crop for images.') flags.DEFINE_integer('crop_height', None, 'Height of the central crop for images.') flags.DEFINE_string('train_log_dir', '/home/OCR/aocr-logs', 'Directory where to write event logs.') flags.DEFINE_string('dataset_name', 'number_plates', 'Name of the dataset. Supported: fsns') flags.DEFINE_string('split_name', 'train', 'Dataset split name to run evaluation for: test,train.') flags.DEFINE_string('dataset_dir', None, 'Dataset root folder.') flags.DEFINE_string('checkpoint', '/home/OCR/aocr-logs/model.ckpt-3000', 'Path for checkpoint to restore weights from.') flags.DEFINE_string('master', '', 'BNS name of the TensorFlow master to use.') # Model hyper parameters flags.DEFINE_float('learning_rate', 0.004, 'learning rate') flags.DEFINE_string('optimizer', 'momentum', 'the optimizer to use') flags.DEFINE_float('momentum', 0.9, 'momentum value for the momentum optimizer if used') flags.DEFINE_bool('use_augment_input', True, 'If True will use image augmentation') # Method hyper parameters # conv_tower_fn flags.DEFINE_string('final_endpoint', 'Mixed_5d', 'Endpoint to cut inception tower') # sequence_logit_fn flags.DEFINE_bool('use_attention', True, 'If True will use the attention mechanism') flags.DEFINE_bool('use_autoregression', True, 'If True will use autoregression (a feedback link)') flags.DEFINE_integer('num_lstm_units', 256, 'number of LSTM units for sequence LSTM') flags.DEFINE_float('weight_decay', 0.00004, 'weight decay for char prediction FC layers') flags.DEFINE_float('lstm_state_clip_value', 10.0, 'cell state is clipped by this value prior to the cell' ' output activation') # 'sequence_loss_fn' flags.DEFINE_float('label_smoothing', 0.1, 'weight for label smoothing') flags.DEFINE_bool('ignore_nulls', True, 'ignore null characters for computing the loss') flags.DEFINE_bool('average_across_timesteps', False, 'divide the returned cost by the total label weight')
def main(argv=None): mnist_blackbox(nb_classes=FLAGS.nb_classes, batch_size=FLAGS.batch_size, learning_rate=FLAGS.learning_rate, nb_epochs=FLAGS.nb_epochs, holdout=FLAGS.holdout, data_aug=FLAGS.data_aug, nb_epochs_s=FLAGS.nb_epochs_s, lmbda=FLAGS.lmbda, aug_batch_size=FLAGS.data_aug_batch_size) if __name__ == '__main__': # General flags flags.DEFINE_integer('nb_classes', 10, 'Number of classes in problem') flags.DEFINE_integer('batch_size', 128, 'Size of training batches') flags.DEFINE_float('learning_rate', 0.001, 'Learning rate for training') # Flags related to oracle flags.DEFINE_integer('nb_epochs', 10, 'Number of epochs to train model') # Flags related to substitute flags.DEFINE_integer('holdout', 150, 'Test set holdout for adversary') flags.DEFINE_integer('data_aug', 6, 'Nb of substitute data augmentations') flags.DEFINE_integer('nb_epochs_s', 10, 'Training epochs for substitute') flags.DEFINE_float('lmbda', 0.1, 'Lambda from arxiv.org/abs/1602.02697') flags.DEFINE_integer('data_aug_batch_size', 512, 'Batch size for augmentation') tf.app.run()
# limitations under the License. # ============================================================================== from __future__ import absolute_import from __future__ import division from __future__ import print_function import deep_cnn import input import metrics from tensorflow.python.platform import app from tensorflow.python.platform import flags flags.DEFINE_string('dataset', 'svhn', 'The name of the dataset to use') flags.DEFINE_integer('nb_labels', 10, 'Number of output classes') flags.DEFINE_string('data_dir', '/tmp', 'Temporary storage') flags.DEFINE_string('train_dir', '/tmp/train_dir', 'Where model ckpt are saved') flags.DEFINE_integer('max_steps', 3000, """Number of training steps to run.""") flags.DEFINE_integer('nb_teachers', 50, """Teachers in the ensemble.""") flags.DEFINE_integer('teacher_id', 0, """ID of teacher being trained.""") flags.DEFINE_boolean('deeper', False, """Activate deeper CNN model""") FLAGS = flags.FLAGS def train_teacher(dataset, nb_teachers, teacher_id):
import numpy as np import tensorflow as tf from tensorflow.python.platform import flags from data_generator import ImageDataGenerator from maml import MASF FLAGS = flags.FLAGS try: os.environ['CUDA_VISIBLE_DEVICES'] = str(sys.argv[1]) except IndexError: print('No GPU given... setting to 0') os.environ['CUDA_VISIBLE_DEVICES'] = '0' ## Dataset PACS flags.DEFINE_integer('num_classes', 800, 'number of classes used in classification.') ## Training options flags.DEFINE_integer('train_iterations', 100000, 'number of training iterations.') flags.DEFINE_integer('meta_batch_size', 64, 'number of images sampled per source domain') flags.DEFINE_float('inner_lr', 0.001, 'step size alpha for inner gradient update on meta-train') flags.DEFINE_float( 'outer_lr', 0.001, 'learning rate for outer updates with (task-loss + meta-loss)') flags.DEFINE_float( 'metric_lr', 0.001, 'learning rate for the metric embedding nn with AdamOptimizer') flags.DEFINE_float('margin', 10, 'distance margin in metric loss')
import tensorflow as tf from tensorflow.python.platform import flags from time import time flags.DEFINE_integer('max_steps', 100, 'max number of steps to run') flags.DEFINE_integer('warmup', 10, 'max number of steps to warmup') flags.DEFINE_integer('batch_size', 1000, 'batch size') FLAGS = flags.FLAGS def main(_): image_name = '../tensorflow/ElCapitan_256_by_256.jpg' file_list = [image_name] print("Running multi-threaded JPEG decode in TensorFlow. Please wait.\n") sess = tf.Session('', config=tf.ConfigProto()) batch_size = FLAGS.batch_size filename_queue = tf.FIFOQueue(-1, tf.string) filename_enq_ops = [] for i in xrange(batch_size): filename_enq_op = filename_queue.enqueue(image_name) filename_enq_ops.append(filename_enq_op) filename_enq_loop = tf.group(*filename_enq_ops) image_queue = tf.FIFOQueue(-1, tf.uint8) enq_ops = [] for i in xrange(batch_size):
# print('rebuild')#rebuild # datasets='mnist' # models=['vgg11', 'vgg13', 'vgg16', 'vgg19', 'resnet18', 'resnet34', 'resnet50', 'resnet101', # 'resnet152', 'googlenet12', 'googlenet16', 'googlenet22'] # attacks=['fgsm'] # mu_vars=['gf'] # for model in ['lenet5']: # for mu_var in mu_vars: # for attack in attacks: # tf.reset_default_graph() # samples_path='../adv_result/mu_'+datasets+'/'+mu_var+'/'+attack+'/'+model+'/train_data' # model_training(datasets=datasets, model_name = model, samples_path=samples_path, # nb_epochs=50, batch_size=128, learning_rate=0.001, attack=attack, mu=True, mu_var=mu_var) def main(argv=None): print('rebuild') # rebuild tf.reset_default_graph() samples_path = '../adv_result/mu_' + FLAGS.datasets + '/' + FLAGS.mu_var + '/' + FLAGS.attack + '/' + FLAGS.model_name + '/train_data' model_training(datasets=FLAGS.datasets, model_name=FLAGS.model_name, samples_path=samples_path, nb_epochs=FLAGS.epochs, batch_size=128, learning_rate=0.001, attack=FLAGS.attack, mu=True, mu_var=FLAGS.mu_var) if __name__ == '__main__': flags.DEFINE_string('datasets', 'mnist', 'The target datasets.') flags.DEFINE_string('attack', 'fgsm', 'attack_method') # '../mt_result/mnist_jsma/adv_jsma' flags.DEFINE_string('model_name', 'lenet1', 'model_name') flags.DEFINE_string('mu_var', 'gf', '') flags.DEFINE_integer('epochs', 50, '') tf.app.run()
Author : charlesXu date: 2018/12/28 ------------------------------------------------- Change Activity: 2018/12/28: ------------------------------------------------- """ import os import tensorflow as tf from tensorflow.python.platform import flags from model import rnn_model from poems import process_poems, generate_batch data_path = 'F:\project\Chatbot_CN\Chatbot_Data\Text_generator\poem\poems.txt' flags.DEFINE_integer('batch_size', 64, 'batch size.') flags.DEFINE_float('learning_rate', 0.01, 'learning rate.') flags.DEFINE_string('model_dir', os.path.abspath('./model'), 'model save path.') flags.DEFINE_string('file_path', os.path.abspath(data_path), 'file name of poems.') flags.DEFINE_string('model_prefix', 'poems', 'model save prefix.') flags.DEFINE_integer('epochs', 50, 'train how many epochs.') # FLAGS = tf.app.flags.FLAGS FLAGS = flags.FLAGS def run_training(): if not os.path.exists(FLAGS.model_dir): os.makedirs(FLAGS.model_dir)
""" Utility functions. """ import numpy as np import os import random import tensorflow as tf import warnings from tensorflow.contrib.layers.python import layers as tf_layers from tensorflow.python.platform import flags from tensorflow.contrib.framework import sort FLAGS = flags.FLAGS flags.DEFINE_integer('spec_iter', 1, 'Number of iterations to normalize spectrum of matrix') flags.DEFINE_float('spec_norm_val', 1.0, 'Desired norm of matrices') flags.DEFINE_bool('downsample', False, 'Wheter to do average pool downsampling') flags.DEFINE_bool('spec_eval', False, 'Set to true to prevent spectral updates') def get_median(v): v = tf.reshape(v, [-1]) m = tf.shape(v)[0] // 2 return tf.nn.top_k(v, m)[m - 1] def set_seed(seed): import torch import numpy import random
from tf_utils.keras_utils import * from tf_utils.make_models import * from tf_utils.tf_utils import * from utils.utils import * FLAGS = flags.FLAGS BATCH_SIZE = 32 STEPS_PER_EPOCH = 50000 // BATCH_SIZE #NOTE: THIS NEEDS ./ flags.DEFINE_string('train_dir', './cifar10_basic/', 'Directory storing the saved model.') flags.DEFINE_string('filename', 'model.ckpt', 'Filename to save model under.') #flags.DEFINE_integer('nb_epochs', 6, 'Number of epochs to train model') flags.DEFINE_integer('batch_size', BATCH_SIZE, 'Size of training batches.') #Must divide evenly into the dataset sizes. (FIX this later)') #for batch_size = 100, is 600 times nb_epochs #STEPS flags.DEFINE_integer('max_steps', 100 * STEPS_PER_EPOCH, 'Number of steps to run trainer.') flags.DEFINE_integer('print_steps', STEPS_PER_EPOCH, 'Print progress every...') flags.DEFINE_integer('eval_steps', STEPS_PER_EPOCH, 'Run evaluation every...') flags.DEFINE_integer('save_steps', STEPS_PER_EPOCH, 'Run evaluation every...') flags.DEFINE_integer('summary_steps', 2 * STEPS_PER_EPOCH, 'Run summary every...') flags.DEFINE_float('learning_rate', 0.0001, 'Learning rate for training') flags.DEFINE_integer('verbosity', 1, 'How chatty') flags.DEFINE_float('label_smooth', 0, 'How much to clip y values (0 for no clipping)') flags.DEFINE_float('epsilon', 0.3, 'Strength of attack')
''' Holds parameter definitions for model. ''' from tensorflow.python.platform import flags import json import math FLAGS = flags.FLAGS flags.DEFINE_integer("attack_epochs", 1, \ "how many iterations to run the attack for") flags.DEFINE_integer("attack_batch_size", 1, "batch size to use in the attack") flags.DEFINE_integer('image_height', 299, \ 'Height of each input images.') flags.DEFINE_integer('image_width', 299, \ 'Width of each input images.') flags.DEFINE_integer("image_channels", 3, \ "Number of channels in input image") flags.DEFINE_string('noise_initial', '', \ 'Specifies the initialization of the noise \ Options: zeros, random_normal' ) flags.DEFINE_float("noise_init_mean", 0.0, \ "when random normally initializing the noise, use this as mean") flags.DEFINE_float("noise_init_stddev", 1.0, \ "when random normally initializing the noise, use this as stddev") flags.DEFINE_integer('num_classes', 1001, \ 'The number of classes this network is trained on') flags.DEFINE_float('pixel_high', 1.0, \ 'The maximum pixel value in this setting') flags.DEFINE_float('pixel_low', 0.0, \ 'The minimum pixel value in this setting') flags.DEFINE_boolean("tf_allow_growth", False, \
A simple usage example: python eval.py """ import tensorflow as tf from tensorflow.contrib import slim from tensorflow import app from tensorflow.python.platform import flags from . import data_provider from . import common_flags FLAGS = flags.FLAGS common_flags.define() # yapf: disable flags.DEFINE_integer('num_batches', 100, 'Number of batches to run eval for.') flags.DEFINE_string('eval_log_dir', '/tmp/attention_ocr/eval', 'Directory where the evaluation results are saved to.') flags.DEFINE_integer('eval_interval_secs', 60, 'Frequency in seconds to run evaluations.') flags.DEFINE_integer('number_of_steps', None, 'Number of times to run evaluation.') # yapf: enable def main(_):
import tflib as lib import tflib.load_lsun import tflib.load_celebA import tflib.small_imagenet import tflib.save_images import tflib.plot import tflib.ops.linear import tflib.ops.conv2d import tflib.ops.batchnorm import tflib.ops.deconv2d import tflib.ops.layernorm flags.DEFINE_string( "mode", "regularized_gan", "MODE: regularized_gan, gan, wgan, wgan-gp, lsgan") flags.DEFINE_string( "architecture", "None", "choice of architecture - see GeneratorAndDiscriminator()") flags.DEFINE_string( "dataset", "celebA", "name of the dataset [ImageNet, lsun, celebA]") flags.DEFINE_integer("n_gpus", 1, "number of gpus to use") flags.DEFINE_integer("iters", 100000, "How many iterations to train for") flags.DEFINE_float( "gamma", 0.1, "noise variance for regularizer [0.1]") flags.DEFINE_boolean("annealing", False, "annealing gamma_0 to decay_factor*gamma_0 [False]") flags.DEFINE_float( "decay_factor", 0.01, "exponential annealing decay rate [0.01]") flags.DEFINE_boolean("unreg", False, "turn regularization off when in regularized_gan mode.") flags.DEFINE_float( "disc_learning_rate", 0.0002, "(initial) learning rate.") flags.DEFINE_float( "gen_learning_rate", 0.0002, "(initial) learning rate.") flags.DEFINE_integer("disc_update_steps", 1, "discriminator update steps.") flags.DEFINE_integer("batch_size", 64, "batch size [64]") flags.DEFINE_string( "root_dir", "RUN_STATS", "root directory [RUN_STATS]") flags.DEFINE_string( "checkpoint_dir", "None", "directory to load the checkpoints from [None]") FLAGS = flags.FLAGS def main():
report.train_clean_train_adv_eval = acc return report def main(argv=None): 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) if __name__ == '__main__': flags.DEFINE_integer('nb_filters', 64, 'Model size multiplier') flags.DEFINE_integer('nb_epochs', 6, 'Number of epochs to train model') flags.DEFINE_integer('batch_size', 128, 'Size of training batches') flags.DEFINE_float('learning_rate', 0.001, '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')) tf.app.run()
# choose the method of preprocess image preprocess_image = preprocess_image_1 train_start = 0 train_end = 73257 test_start = 0 test_end = 26032 # Get SVHN test data X_train, Y_train, X_test, Y_test = data_svhn(train_start=train_start, train_end=train_end, test_start=test_start, test_end=test_end, preprocess=preprocess_image) sample = X_test[198:199] imsave(FLAGS.sample, deprocess_image_1(sample)) cw(datasets=FLAGS.datasets, sample=FLAGS.sample, model_name=FLAGS.model, target=FLAGS.target, store_path=FLAGS.store_path) if __name__ == '__main__': flags.DEFINE_string('datasets', 'mnist', 'The target datasets.') flags.DEFINE_string('sample', '../datasets/integration/mnist/2.png', 'The path to load sample.') flags.DEFINE_string('model', 'lenet1', 'The name of model.') flags.DEFINE_integer('target', 2, 'target') flags.DEFINE_string('store_path', '../mt_result/integration/cw/mnist', 'The path to store adversaries.') tf.app.run()
feed_dict = {x: adv} probabilities = sess.run(preds, feed_dict) print(probabilities) #Save adversial image two_d_img = (np.reshape(adv, (28, 28)) * 255).astype(np.uint8) from PIL import Image save_image = Image.fromarray(two_d_img) save_image = save_image.convert('RGB') save_image.save("cw_attack_res.png") # Close TF session sess.close() return def main(argv=None): mnist_tutorial_cw(nb_classes=FLAGS.nb_classes, attack_iterations=FLAGS.attack_iterations, targeted=FLAGS.targeted) if __name__ == '__main__': flags.DEFINE_integer('nb_classes', 10, 'Number of output classes') flags.DEFINE_integer('attack_iterations', 100, 'Number of iterations to run attack; 1000 is good') flags.DEFINE_boolean('targeted', True, 'Run the tutorial in targeted mode?') tf.app.run()
an equal separation distribution of the video images. Implementation supports Optical Flow (currently OpenCV's calcOpticalFlowFarneback) as an additional 4th channel. """ from tensorflow.python.platform import gfile from tensorflow.python.platform import flags from tensorflow.python.platform import app import cv2 as cv2 import numpy as np import math import os import tensorflow as tf import time FLAGS = flags.FLAGS flags.DEFINE_integer('n_videos_in_record', 10, 'Number of videos stored in one single tfrecord file') flags.DEFINE_string( 'image_color_depth', "uint8", 'Color depth as string for the images stored in the tfrecord files. ' 'Has to correspond to the source video color depth. ' 'Specified as dtype (e.g. uint8 or uint16)') flags.DEFINE_string('file_suffix', "*.mp4", 'defines the video file type, e.g. .mp4') flags.DEFINE_string('source', './example/input', 'Directory with video files') flags.DEFINE_string('destination', './example/output', 'Directory for storing tf records') flags.DEFINE_boolean( 'optical_flow', True, 'Indicates whether optical flow shall be computed and added as fourth ' 'channel.')
# ERROR : Could not create cudnn handle: CUDNN_STATUS_NOT_INITIALIZED tf_config = tf.compat.v1.ConfigProto() tf_config.gpu_options.allow_growth = True tf_config.allow_soft_placement = True tf_config.log_device_placement = False #tf_config.gpu_options.per_process_gpu_memory_fraction=0.95 #tf_config.gpu_options.allocator_type = 'BFC' tf.compat.v1.keras.backend.set_session(tf.Session(config=tf_config)) FLAGS = flags.FLAGS common_flags.define() # yapf: disable flags.DEFINE_integer('task', 0, 'The Task ID. This value is used when training with ' 'multiple workers to identify each worker.') flags.DEFINE_integer('ps_tasks', 0, 'The number of parameter servers. If the value is 0, then' ' the parameters are handled locally by the worker.') flags.DEFINE_integer('save_summaries_secs', 60, 'The frequency with which summaries are saved, in ' 'seconds.') flags.DEFINE_integer('save_interval_secs', 600, 'Frequency in seconds of saving the model.') flags.DEFINE_integer('max_number_of_steps', int(1e10), 'The maximum number of gradient steps.')
from tqdm import tqdm import tensorflow as tf from tensorflow.python.platform import app from tensorflow.python.platform import flags import tensorflow.contrib.slim as slim import input_data import models import utils as u FLAGS = flags.FLAGS flags.DEFINE_integer( 'num_labeled', 100, 'Number of labeled samples to use for training. (None = all labeled samples)' ) flags.DEFINE_integer('batch_size', 100, 'Number of samples used per batch.') flags.DEFINE_integer('num_iters', 1000000, 'Number of training steps.') flags.DEFINE_integer('eval_interval', 1000, 'Number of steps between evaluations.') flags.DEFINE_float('learning_rate', 0.001, 'Initial learning rate for optimizer.') flags.DEFINE_float('lr_decay_steps', 5000, 'Interval of steps for learning rate decay.') flags.DEFINE_float('lr_decay_factor', 0.33, 'Learning rate exponential decay factor.') def main(_): data_tr, labels_tr, data_te, labels_te, unlabeled = input_data.load_mnist(
import numpy as np import pickle import random import tensorflow as tf from data_generator import DataGenerator from maml import MAML from tensorflow.python.platform import flags FLAGS = flags.FLAGS ## Dataset/method options flags.DEFINE_string('datasource', 'sinusoid', 'sinusoid or omniglot or miniimagenet') flags.DEFINE_integer( 'num_classes', 5, 'number of classes used in classification (e.g. 5-way classification).') # oracle means task id is input (only suitable for sinusoid) flags.DEFINE_string('baseline', None, 'oracle, or None') ## Training options flags.DEFINE_integer('pretrain_iterations', 0, 'number of pre-training iterations.') flags.DEFINE_integer( 'metatrain_iterations', 15000, 'number of metatraining iterations.') # 15k for omniglot, 50k for sinusoid flags.DEFINE_integer('meta_batch_size', 25, 'number of tasks sampled per meta-update') flags.DEFINE_float('meta_lr', 0.001, 'the base learning rate of the generator') flags.DEFINE_integer( 'update_batch_size', 5,
# Run an evaluation of our model against fgsm total = 0 correct = 0 for xs, ys in test_loader: adv_preds = sess.run(adv_preds_op, feed_dict={x_op: xs}) correct += (np.argmax(adv_preds, axis=1) == ys).sum() total += len(xs) acc = float(correct) / total print('Adv accuracy: {:.3f}'.format(acc * 100)) report.clean_train_adv_eval = acc return report def main(_=None): mnist_tutorial(nb_epochs=FLAGS.nb_epochs, batch_size=FLAGS.batch_size, learning_rate=FLAGS.learning_rate) 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') tf.app.run()
# Close TF session sess.close() # Finally, block & display a grid of all the adversarial examples if viz_enabled: import matplotlib.pyplot as plt plt.close(figure) _ = grid_visual(grid_viz_data) return report def main(argv=None): mnist_tutorial_jsma(viz_enabled=FLAGS.viz_enabled, nb_epochs=FLAGS.nb_epochs, batch_size=FLAGS.batch_size, nb_classes=FLAGS.nb_classes, source_samples=FLAGS.source_samples, learning_rate=FLAGS.learning_rate) if __name__ == '__main__': flags.DEFINE_boolean('viz_enabled', False, 'Visualize adversarial ex.') flags.DEFINE_integer('nb_epochs', 6, 'Number of epochs to train model') flags.DEFINE_integer('batch_size', 128, 'Size of training batches') flags.DEFINE_integer('nb_classes', 10, 'Number of output classes') flags.DEFINE_integer('source_samples', 600, 'Nb of test inputs to attack') flags.DEFINE_float('learning_rate', 0.001, 'Learning rate for training') tf.app.run()
import numpy as np from scipy.misc import imsave import matplotlib.pyplot as plt from easydict import EasyDict from utils import ReplayBuffer from torch.optim import Adam, SGD import torch.multiprocessing as mp import torch.distributed as dist from torch.nn.parallel import DistributedDataParallel as DDP FLAGS = flags.FLAGS # Distributed training hyperparameters flags.DEFINE_integer('nodes', 1, 'number of nodes for training') flags.DEFINE_integer('gpus', 1, 'number of gpus per nodes') flags.DEFINE_integer('node_rank', 0, 'rank of node') # Configurations for distributed training flags.DEFINE_string('master_addr', '8.8.8.8', 'address of communicating server') flags.DEFINE_string('port', '10002', 'port of training') flags.DEFINE_bool('slurm', False, 'whether we are on slurm') flags.DEFINE_bool('repel_im', True, 'maximize entropy by repeling images from each other') flags.DEFINE_bool('hmc', False,