sigma=FLAGS.SIGMA, batch_size=FLAGS.BATCH_SIZE, eps=FLAGS.EPS, steps=FLAGS.STEPS, kappa=FLAGS.KAPPA, alpha=FLAGS.ALPHA) if __name__ == '__main__': ROOT_PATH = "../GTSRB" SAVE_PATH = "../GTSRB/models" train_data_dir = os.path.join(ROOT_PATH, "train.p") test_data_dir = os.path.join(ROOT_PATH, "test.p") model_dir = os.path.join(SAVE_PATH, "LeNet_1") model_dir1 = os.path.join(SAVE_PATH, "AlexNet") # General flags flags.DEFINE_integer('BATCH_SIZE', 128, 'Size of training batches') flags.DEFINE_float('MU', 0, 'The mean of thetruncated normal distribution') flags.DEFINE_float( 'SIGMA', 0.1, 'The standard deviation of the truncated normal distribution') flags.DEFINE_boolean('ADD_DROPOUT', False, 'Decide if add dropout process when training') flags.DEFINE_boolean('DROPOUT', 0.5, 'Dropout value') flags.DEFINE_string('ATTACK_TYPE', 'fgsm', 'Select one attack type') flags.DEFINE_float('EPS', 0.3, 'The epsilon (input variation parameter)') flags.DEFINE_float('KAPPA', 100, 'Carlini attack confidence') flags.DEFINE_integer('STEPS', 10, 'Number of iteration') flags.DEFINE_float('ALPHA', 0.05, 'parameter for random noise') app.run()
return report def main(argv=None): mnist_tutorial_cw(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, attack_iterations=FLAGS.attack_iterations, model_path=FLAGS.model_path, targeted=FLAGS.targeted) if __name__ == '__main__': flags.DEFINE_boolean('viz_enabled', True, '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', 10, 'Nb of test inputs to attack') flags.DEFINE_float('learning_rate', 0.001, 'Learning rate for training') flags.DEFINE_string('model_path', os.path.join("models", "mnist"), 'Path to save or load the model file') flags.DEFINE_boolean('attack_iterations', 100, 'Number of iterations to run attack; 1000 is good') flags.DEFINE_boolean('targeted', True, 'Run the tutorial in targeted mode?') app.run()
'Batch size to be used while running framework') flags.DEFINE_integer('num_ensemble_models', 1, 'Number of models to use in ensemble for highres-faces') flags.DEFINE_float( 'active_ratio', 1.0, 'Upper cap on ratio of unlabelled examples to be querried for labels') flags.DEFINE_float('split_ratio', 0.5, 'How much of disguised-face data to use for training M2') flags.DEFINE_float('disparity_ratio', 0.25, 'What percentage of data to pick to pass on to oracle') flags.DEFINE_float( 'eps', 0.1, 'Region around equiboundary for even considering querying the oracle') flags.DEFINE_boolean('augment', False, 'Augment data while finetuning covariate-based model?') flags.DEFINE_boolean('refine_models', False, 'Refine previously trained models?') flags.DEFINE_boolean( 'blind_strategy', False, 'If yes, pick all where disparity >= 0.5, otherwise pick according to disparity_ratio' ) if __name__ == "__main__": # Reproducability init() # Set resolution according to flag GlobalConstants.low_res = (FLAGS.lowRes, FLAGS.lowRes) print("== Low resolution : %s ==" % str(GlobalConstants.low_res))
'If greater than 0 then the gradients would be clipped by ' 'it.') flags.DEFINE_bool('sync_replicas', False, 'If True will synchronize replicas during training.') flags.DEFINE_integer('replicas_to_aggregate', 1, 'The number of gradients updates before updating params.') flags.DEFINE_integer('total_num_replicas', 1, 'Total number of worker replicas.') flags.DEFINE_integer('startup_delay_steps', 15, 'Number of training steps between replicas startup.') flags.DEFINE_boolean('reset_train_dir', False, 'If true will delete all files in the train_log_dir') flags.DEFINE_boolean('show_graph_stats', False, 'Output model size stats to stderr.') # yapf: enable TrainingHParams = collections.namedtuple('TrainingHParams', [ 'learning_rate', 'optimizer', 'momentum', 'use_augment_input', ]) def get_training_hparams(): return TrainingHParams(learning_rate=FLAGS.learning_rate,
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(SAVE_PATH) # 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()
# pylint: disable=g-direct-tensorflow-import # pylint: disable=g-direct-third-party-import from mesh_tensorflow.experimental import input_reader from mesh_tensorflow.experimental import unet from tensorflow.contrib import summary as contrib_summary from tensorflow.contrib import tpu from tensorflow.contrib.tpu.python.tpu import device_assignment from tensorflow.python.framework import ops from tensorflow.python.ops import control_flow_ops from tensorflow.python.platform import flags from tensorflow.python.tpu.ops import tpu_ops FLAGS = flags.FLAGS flags.DEFINE_boolean('use_tpu', True, 'Use TPU or GPU.') flags.DEFINE_float('lr', 0.003, 'Learning rate.') flags.DEFINE_float('lr_drop_steps', 20000, 'Learning rate drops for every `lr_drop_steps` steps.') flags.DEFINE_float('lr_drop_rate', 0.3, 'Learning rate drops by this amount.') flags.DEFINE_integer('num_train_iterations_per_loop', 500, 'Number of training iterations per loop.') flags.DEFINE_integer('num_eval_iterations_per_loop', 2, 'Number of eval iterations per loop.') flags.DEFINE_integer('num_training_loops', 1000, 'Number of training loops.') flags.DEFINE_string('mesh_shape', 'rows:4, columns:4, cores:2', 'mesh shape') flags.DEFINE_string('master', '', 'Can be a headless master.') flags.DEFINE_string('checkpoint_dir', '', 'Path to saved models.') flags.DEFINE_integer('save_checkpoints_steps', 500,
import functools import os import mesh_tensorflow as mtf import numpy as np import tensorflow as tf # tf # pylint: disable=g-direct-tensorflow-import,g-direct-third-party-import from mesh_tensorflow.experimental import data_aug_lib from tensorflow.python.platform import flags FLAGS = flags.FLAGS flags.DEFINE_boolean('sampled_2d_slices', False, 'Whether to build model on 2D CT slices instead of 3D.') flags.DEFINE_integer('ct_resolution', 128, 'Resolution of CT images along depth, height and ' 'width dimensions.') flags.DEFINE_integer('n_dataset_read_interleave', 16, 'The number of interleave processes.') flags.DEFINE_integer('n_dataset_processes', 16, 'The number of data augmentation processes.') flags.DEFINE_integer('batch_size_train', 32, 'Training batch size.') flags.DEFINE_integer('batch_size_eval', 32, 'Evaluation batch size.') flags.DEFINE_integer('image_nx_block', 8, 'The number of x blocks.') flags.DEFINE_integer('image_ny_block', 8, 'The number of y blocks.') flags.DEFINE_integer('image_c', 1, 'The number of input image channels. '
# How often to save a model checkpoint SAVE_INTERVAL = 2500 FLAGS = flags.FLAGS flags.DEFINE_string('trace', "./", 'directory for model checkpoints.') flags.DEFINE_integer('num_iterations', 300000, 'number of training iterations.') flags.DEFINE_string('pretrained_model', '', 'filepath of a pretrained model to initialize from.') flags.DEFINE_string( 'mode', '', 'selection from four modes of ["flow", "depth", "depthflow", "stereo"]') flags.DEFINE_string('train_test', 'train', 'whether to train or test') flags.DEFINE_boolean("retrain", True, "whether to reset the iteration counter") flags.DEFINE_string('data_dir', '', 'root filepath of data.') flags.DEFINE_string('train_file', './filenames/kitti_train_files_png_4frames.txt', 'training file') flags.DEFINE_string('gt_2012_dir', '', 'directory of ground truth of kitti 2012') flags.DEFINE_string('gt_2015_dir', '', 'directory of ground truth of kitti 2015') flags.DEFINE_integer('batch_size', 4, 'batch size for training') flags.DEFINE_float('learning_rate', 0.0001, 'the base learning rate of the generator') flags.DEFINE_integer('num_gpus', 1, 'the number of gpu to use')
args=eval_params) report.train_adv_train_adv_eval = accuracy return report def main(argv=None): from 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()
'Learning rate drops for every `lr_drop_steps` steps.') flags.DEFINE_float('lr_drop_rate', 0.3, 'Learning rate drops by this amount.') flags.DEFINE_integer('num_train_iterations_per_loop', 500, 'Number of training iterations per loop.') flags.DEFINE_integer('num_eval_iterations_per_loop', 2, 'Number of eval iterations per loop.') flags.DEFINE_integer('num_training_loops', 1000, 'Number of training loops.') flags.DEFINE_string('mesh_shape', 'rows:4, columns:4, cores:2', 'mesh shape') flags.DEFINE_string('master', '', 'Can be a headless master.') flags.DEFINE_string('checkpoint_dir', '', 'Path to saved models.') flags.DEFINE_integer('save_checkpoints_steps', 500, 'Frequency for saving models.') flags.DEFINE_boolean('write_summary', True, 'Whether to write summary.') flags.DEFINE_string('summary_dir', '', 'Path to saved summaries.') flags.DEFINE_string('pred_output_dir', '', 'Path to saved pred results.') class _CapturedObject(object): """A placeholder to capture an object. This is useful when we need to capture a Python object in the Tensorflow control flow body function and use it outside the control flow. """ def __init__(self): self._object = None self._captured = False def capture(self, o):
flags.DEFINE_float('beta1', 0.0, 'beta 1') flags.DEFINE_float('beta2', 0.9, 'beta 2') # end of MNIST data specification # general configurations below flags.DEFINE_string('gpus', '', 'visible GPU list') flags.DEFINE_string('type', '', 'type of the model, classification or regression') flags.DEFINE_string('data_dir', '', 'directory of data') flags.DEFINE_string('output_dir', '', 'directory for model outputs.') flags.DEFINE_string('checkpoint_dir', '', 'directory of checkpoint files.') # subject adaptation flags.DEFINE_boolean('adp', True, 'adaptation or not') flags.DEFINE_integer('batch_size', 64, 'batch size for training.') flags.DEFINE_integer('train_batch_size', 0, 'batch size for training.') flags.DEFINE_integer('xval_batch_size', 0, 'batch size for cross evaluation') flags.DEFINE_integer('test_batch_size', 0, 'batch size for test') flags.DEFINE_integer('summary_interval', 5, 'how often to record tensorboard summaries.') flags.DEFINE_integer('validation_interval', 10, 'how often to run a batch through the validation model') # flags.DEFINE_integer('save_interval', 2000, 'how often to save a model checkpoint.') flags.DEFINE_boolean('validation', True, 'whether do validation or not') flags.DEFINE_boolean('evaluate', True, 'evaluate using validation data to select model parameters') flags.DEFINE_integer('sample_size', 0, 'sample size for analyzing the model')
def tqdm(*args, **kwargs): if args: return args[0] return kwargs.get('iterable', None) flags.DEFINE_string( 'data_dir', '~/.keras/datasets/costar_plush_block_stacking_dataset_v0.4/', 'Directory for collecting the dataset files') flags.DEFINE_string('glob_filename', '*success*.h5f', 'File path to glob for dataset files.') flags.DEFINE_boolean( 'ascending', False, 'Sort in ascending (1 to 100) or descending (100 to 1) order.') flags.DEFINE_string( 'save_txt_prefix', 'costar_block_stacking_v0.4_success_only_', 'Prefix with which to to save the sorted output txt file with the train test and validation sets' ) flags.DEFINE_string('save_dir', None, 'Where to save the txt files, defaults to data_dir') flags.DEFINE_integer( 'seed', 0, 'numpy seed for shuffling the data, so you can generate this list in a repeatable way' )
from cleverhans.attacks import FastGradientMethod,BasicIterativeMethod,MomentumIterativeMethod, CarliniWagnerL2 from cleverhans.utils_keras import cnn_model, vgg_model from cleverhans.utils_tf_multiple_pr_cifar10 import model_train, model_eval, batch_eval, tf_model_load from cleverhans.utils import set_log_level FLAGS = flags.FLAGS flags.DEFINE_string('train_dir', '/home/labiai/Jiacang/Experiments/tmp/pr/cifar', 'Directory storing the saved model.') flags.DEFINE_string( 'filename', 'cifar10.ckpt', 'Filename to save model under.') flags.DEFINE_integer('nb_epochs', 10000, '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_boolean('viz_enabled', False, 'Visualize adversarial ex.') flags.DEFINE_integer('source_samples', 10, 'Nb of test inputs to attack') flags.DEFINE_string('model_path', os.path.join("models", "mnist"), 'Path to save or load the model file') flags.DEFINE_integer('attack_iterations', 1000, 'Number of iterations to run attack; 1000 is good') flags.DEFINE_boolean('targeted', False, 'Run the tutorial in targeted mode?') n_input = 32*32*3 # MNIST data input (img shape: 28*28) numColorOutput = 3 os.environ['CUDA_VISIBLE_DEVICES'] = '0' type = 'single' type = 'multiple' mode = "nonpr"
# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """Tests for our flags implementation.""" import sys from tensorflow.python.platform import app from tensorflow.python.platform import flags FLAGS = flags.FLAGS flags.DEFINE_boolean('myflag', False, '') def main(argv): if (len(argv) != 3): print("Length of argv was not 3: ", argv) sys.exit(-1) if argv[1] != "--passthrough": print("--passthrough argument not in argv") sys.exit(-1) if argv[2] != "extra": print("'extra' argument not in argv") sys.exit(-1)
import numpy as np import tensorflow as tf from utils import * from model.rnn import BiRNN from tensorflow.python.platform import flags from tensorflow.python.platform import app flags.DEFINE_string('mode', 'train', 'set whether to train or test') flags.DEFINE_string('model', 'BiRNN', 'set the model to use, BiRNN, CNN') flags.DEFINE_string('rnncell', 'lstm', 'set the rnncell to use, rnn, gru, lstm...') flags.DEFINE_integer('num_layer', 3, 'set the layers for rnn') flags.DEFINE_boolean('layerNormalization', True, 'set whether to apply layer normalization to rnn cell') flags.DEFINE_integer('batch_size', 64, 'set the batch size') flags.DEFINE_integer('num_hidden', 512, 'set the hidden size of rnn cell') flags.DEFINE_integer('num_feature', 39, 'set the size of input feature') flags.DEFINE_integer('num_class', 462, 'set the speakrs') flags.DEFINE_integer('num_epoch', 200, 'set the number of epochs') flags.DEFINE_float('learning_rate', 0.0001, 'set the learning rate') flags.DEFINE_float('keep_prob', 0.8, 'set probability of dropout') flags.DEFINE_float( 'grad_clip', -1, 'set the threshold of gradient clipping, -1 denotes no clipping') flags.DEFINE_string('datadir', '../data', 'set the data root directory') flags.DEFINE_string('logdir', '../log', 'set the log directory') FLAGS = flags.FLAGS
from skimage.io import imread dir_path = dirname(os.path.realpath(__file__)) # Basic model parameters as external flags. FLAGS = flags.FLAGS flags.DEFINE_string('data_set', '/middlebury', 'Data Set in use') flags.DEFINE_string('grid_params', "{ 'sigma_luma' : 2,'sigma_chroma': 4, 'sigma_spatial': 2}", "Bilateral grid parameters") flags.DEFINE_string('bs_params', "{'lam': 30, 'A_diag_min': 1e-5, 'cg_tol': 1e-5, 'cg_maxiter': 25}", "Bilateral solver parameters") flags.DEFINE_boolean('write_flows', False, 'Write confidence, .flo and img files') flags.DEFINE_integer('batchsize', 20, 'Batch size for eval loop.') flags.DEFINE_integer('eval_interval_secs', 300, 'How many seconds between executions of the eval loop.') flags.DEFINE_integer('testsize', 8, 'Number of test samples') flags.DEFINE_integer('d_shape_img', [388, 584, 3], 'Data shape: width, height, channels') flags.DEFINE_integer('d_shape_flow', [388, 584, 2], 'Data shape: width, height, channels')
# Calculating train error if testing: eval_par = {'batch_size': batch_size} acc = model_eval(sess, x, y, preds_adv, x_train, y_train, args=eval_par) report.train_clean_train_adv_eval = acc return report def main(argv=None): cifar_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, method=FLAGS.method) if __name__ == '__main__': flags.DEFINE_integer('nb_epochs', 40, '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_string('train_dir', 'cifar_ff_model', 'Directory where to save model.') flags.DEFINE_string('filename', 'FF_init_model.ckpt', 'Checkpoint filename.') flags.DEFINE_boolean('load_model', True, 'Load saved model or train.') flags.DEFINE_string('method', 'FGSM', 'Adversarial attack method') tf.app.run()
will watch each directory. You can also assign names to individual log directories by putting a colon between the name and the path, as in tensorboard --logdir=name1:/path/to/logs/1,name2:/path/to/logs/2 """) flags.DEFINE_string( 'host', '0.0.0.0', 'What host to listen to. Defaults to ' 'serving on 0.0.0.0, set to 127.0.0.1 (localhost) to' 'disable remote access (also quiets security warnings).') flags.DEFINE_integer('port', 6006, 'What port to serve TensorBoard on.') flags.DEFINE_boolean( 'purge_orphaned_data', True, 'Whether to purge data that ' 'may have been orphaned due to TensorBoard restarts. ' 'Disabling purge_orphaned_data can be used to debug data ' 'disappearance.') flags.DEFINE_integer('reload_interval', 5, 'How often the backend should load ' 'more data.') # Inspect Mode flags flags.DEFINE_boolean( 'inspect', False, """Use this flag to print out a digest of your event files to the command line, when no data is shown on TensorBoard or the data shown looks weird. Example usages: tensorboard --inspect --event_file=myevents.out
import keras from keras import backend as K import keras_contrib from grasp_loss import gaussian_kernel_2D from inception_preprocessing import preprocess_image import random_crop as rcp flags.DEFINE_string('data_dir', os.path.join(os.path.expanduser("~"), '.keras', 'datasets', 'cornell_grasping'), """Path to dataset in TFRecord format (aka Example protobufs) and feature csv files.""") flags.DEFINE_string('grasp_dataset', 'all', 'TODO(ahundt): integrate with brainrobotdata or allow subsets to be specified') flags.DEFINE_boolean('grasp_download', False, """Download the grasp_dataset to data_dir if it is not already present.""") flags.DEFINE_string('train_filename', 'cornell-grasping-dataset-train.tfrecord', 'filename used for the training dataset') flags.DEFINE_string('evaluate_filename', 'cornell-grasping-dataset-evaluate.tfrecord', 'filename used for the evaluation dataset') flags.DEFINE_string('test_filename', 'cornell-grasping-dataset-test.tfrecord', 'filename used for the evaluation dataset') flags.DEFINE_integer('image_size', 224, """DEPRECATED - this doesn't do anything right now. Provide square images of this size.""") flags.DEFINE_integer('num_preprocess_threads', 12, """Number of preprocessing threads per tower. """ """Please make this a multiple of 4.""") flags.DEFINE_integer('num_readers', 20, """Number of parallel threads reading from the dataset.""") flags.DEFINE_integer('input_queue_memory_factor', 12, """Size of the queue of preprocessed images. """ """Default is ideal but try smaller values, e.g. """ """4, 2 or 1, if host memory is constrained. See """ """comments in code for more details.""")
# pylint: disable=g-direct-tensorflow-import # pylint: disable=g-direct-third-party-import from mesh_tensorflow.experimental import input_reader from mesh_tensorflow.experimental import unet from tensorflow.contrib import summary as contrib_summary from tensorflow.contrib import tpu from tensorflow.contrib.tpu.python.tpu import device_assignment from tensorflow.python.framework import ops from tensorflow.python.ops import control_flow_ops from tensorflow.python.platform import flags from tensorflow.python.tpu.ops import tpu_ops FLAGS = flags.FLAGS flags.DEFINE_boolean('use_tpu', True, 'Use TPU or GPU.') flags.DEFINE_float('lr', 0.003, 'Learning rate.') flags.DEFINE_float('lr_drop_steps', 20000, 'Learning rate drops for every `lr_drop_steps` steps.') flags.DEFINE_float('lr_drop_rate', 0.3, 'Learning rate drops by this amount.') flags.DEFINE_integer('num_train_iterations_per_loop', 500, 'Number of training iterations per loop.') flags.DEFINE_integer('num_eval_iterations_per_loop', 2, 'Number of eval iterations per loop.') flags.DEFINE_integer('num_training_loops', 1000, 'Number of training loops.') flags.DEFINE_string('mesh_shape', 'rows:4, columns:4, cores:2', 'mesh shape') flags.DEFINE_string('master', '', 'Can be a headless master.') flags.DEFINE_string('checkpoint_dir', '', 'Path to saved models.') flags.DEFINE_integer('save_checkpoints_steps', 500,
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 from cleverhans.attacks import jsma from cleverhans.attacks_tf import jacobian_graph from cleverhans.utils import other_classes, cnn_model, pair_visual, grid_visual FLAGS = flags.FLAGS flags.DEFINE_string('train_dir', '/tmp', 'Directory storing the saved model.') flags.DEFINE_string('filename', 'mnist.ckpt', 'Filename to save model under.') flags.DEFINE_boolean('viz_enabled', True, 'Enable sample visualization.') 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 classification classes') flags.DEFINE_integer('img_rows', 28, 'Input row dimension') flags.DEFINE_integer('img_cols', 28, 'Input column dimension') flags.DEFINE_integer('nb_channels', 1, 'Nb of color channels in the input.') flags.DEFINE_integer('nb_filters', 64, 'Number of convolutional filter to use') flags.DEFINE_integer('nb_pool', 2, 'Size of pooling area for max pooling') flags.DEFINE_integer('source_samples', 10, 'Nb of test set examples to attack') flags.DEFINE_float('learning_rate', 0.1, 'Learning rate for training') def main(argv=None): """ MNIST tutorial for the Jacobian-based saliency map approach (JSMA)
from tensorflow.python.platform import flags from tensorflow.python.training import server_lib FLAGS = flags.FLAGS flags.DEFINE_string( "cluster_spec", "", """Cluster spec: SPEC. SPEC is <JOB>(,<JOB>)*," JOB is <NAME>|<HOST:PORT>(;<HOST:PORT>)*," NAME is a valid job name ([a-z][0-9a-z]*)," HOST is a hostname or IP address," PORT is a port number." E.g., local|localhost:2222;localhost:2223, ps|ps0:2222;ps1:2222""") flags.DEFINE_string("job_name", "", "Job name: e.g., local") flags.DEFINE_integer("task_id", 0, "Task index, e.g., 0") flags.DEFINE_boolean("verbose", False, "Verbose mode") def parse_cluster_spec(cluster_spec, cluster): """Parse content of cluster_spec string and inject info into cluster protobuf. Args: cluster_spec: cluster specification string, e.g., "local|localhost:2222;localhost:2223" cluster: cluster protobuf. Raises: ValueError: if the cluster_spec string is invalid. """ job_strings = cluster_spec.split(",")
def main(argv=None): detection(nb_epochs=FLAGS.nb_epochs, batch_size=FLAGS.batch_size, data_name=FLAGS.dataset, attack_type=FLAGS.attack_type, ) if __name__ == '__main__': flags.DEFINE_integer('nb_filters', 64, 'Model size multiplier') flags.DEFINE_integer('nb_epochs', 10, 'Number of epochs to train model') flags.DEFINE_integer('batch_size', 128, 'Size of training batches') flags.DEFINE_integer('nb_classes', 10, 'Number of classes') flags.DEFINE_float('train_fpr', 0.05, 'faes rate to decide threshold') flags.DEFINE_string('dataset', 'mnist', 'train dataset name') flags.DEFINE_string("attack_type", "fgsm", 'attack to detect') flags.DEFINE_string("test_attack_type", "fgsm", 'attack to detect') flags.DEFINE_bool("is_train", False, "train online or load from file") flags.DEFINE_string("detection_type", "negative", "which detection type to use") flags.DEFINE_string('result_folder', "results", 'The output folder for results.') flags.DEFINE_bool('use_cache', False, 'use history cache or get adversarial examples online') flags.DEFINE_boolean('detection_train_test_mode', True, 'Split into train/test datasets.') flags.DEFINE_float('stdevs', 0.05, 'L-2 perturbation size is equal to that of the adversarial samples') flags.DEFINE_string('similarity_type', "cos", 'similarity index') flags.DEFINE_string('label_type', "type1", 'label assignment') tf.app.run()
from speechvalley.utils import load_batched_data, describe, output_to_sequence, list_dirs, logging, count_params, get_num_classes, check_path_exists, dotdict, activation_functions_dict, optimizer_functions_dict from speechvalley.models import DBiRNN from tensorflow.python.platform import flags from tensorflow.python.platform import app flags.DEFINE_string('task', 'libri', 'set task name of this program') flags.DEFINE_string('train_dataset', 'train-clean-100', 'set the training dataset') flags.DEFINE_string('dev_dataset', 'dev-clean', 'set the development dataset') flags.DEFINE_string('test_dataset', 'test-clean', 'set the test dataset') flags.DEFINE_string('mode', 'test', 'set whether to train, dev or test') flags.DEFINE_boolean('keep', True, 'set whether to restore a model, when test mode, keep should be set to True') flags.DEFINE_string('level', 'cha', 'set the task level, phn, cha, or seq2seq, seq2seq will be supported soon') flags.DEFINE_string('model', 'DBiRNN', 'set the model to use, DBiRNN, BiRNN, ResNet..') flags.DEFINE_string('rnncell', 'lstm', 'set the rnncell to use, rnn, gru, lstm...') flags.DEFINE_integer('num_layer', 2, 'set the layers for rnn') flags.DEFINE_string('activation', 'tanh', 'set the activation to use, sigmoid, tanh, relu, elu...') flags.DEFINE_string('optimizer', 'adam', 'set the optimizer to use, sgd, adam...') flags.DEFINE_boolean('layerNormalization', False, 'set whether to apply layer normalization to rnn cell') flags.DEFINE_integer('batch_size', 64, 'set the batch size') flags.DEFINE_integer('num_hidden', 256, 'set the hidden size of rnn cell') flags.DEFINE_integer('num_feature', 39, 'set the size of input feature') flags.DEFINE_integer('num_classes', 30, 'set the number of output classes') flags.DEFINE_integer('num_epochs', 1, 'set the number of epochs') flags.DEFINE_float('lr', 0.0001, 'set the learning rate') flags.DEFINE_float('dropout_prob', 0.1, 'set probability of dropout')
flags.DEFINE_string( 'logdir', None, """logdir specifies the directory where TensorBoard will look to find TensorFlow event files that it can display. TensorBoard will recursively walk the directory structure rooted at logdir, looking for .*tfevents.* files. You may also pass a comma separated list of log directories, and TensorBoard will watch each directory. You can also assign names to individual log directories by putting a colon between the name and the path, as in tensorboard --logdir=name1:/path/to/logs/1,name2:/path/to/logs/2 """) flags.DEFINE_boolean( 'debug', False, 'Whether to run the app in debug mode. ' 'This increases log verbosity to DEBUG.') flags.DEFINE_string( 'host', '0.0.0.0', 'What host to listen to. Defaults to ' 'serving on 0.0.0.0, set to 127.0.0.1 (localhost) to' 'disable remote access (also quiets security warnings).') flags.DEFINE_integer('port', 6006, 'What port to serve TensorBoard on.') FLAGS = flags.FLAGS # How many elements to store per tag, by tag type TENSORBOARD_SIZE_GUIDANCE = { event_accumulator.COMPRESSED_HISTOGRAMS: 500, event_accumulator.IMAGES: 4,
# 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', True, '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', 10, 'Nb of test inputs to attack') flags.DEFINE_float('learning_rate', 0.001, 'Learning rate for training') tf.app.run()
from __future__ import absolute_import from __future__ import division from __future__ import print_function import copy import sys import unittest from tensorflow.python.platform import app from tensorflow.python.platform import flags flags.DEFINE_string("string_foo", "default_val", "HelpString") flags.DEFINE_integer("int_foo", 42, "HelpString") flags.DEFINE_float("float_foo", 42.0, "HelpString") flags.DEFINE_boolean("bool_foo", True, "HelpString") flags.DEFINE_boolean("bool_negation", True, "HelpString") flags.DEFINE_boolean("bool-dash-negation", True, "HelpString") flags.DEFINE_boolean("bool_a", False, "HelpString") flags.DEFINE_boolean("bool_c", False, "HelpString") flags.DEFINE_boolean("bool_d", True, "HelpString") flags.DEFINE_bool("bool_e", True, "HelpString") FLAGS = flags.FLAGS class FlagsTest(unittest.TestCase): def testString(self): res = FLAGS.string_foo self.assertEqual(res, "default_val") FLAGS.string_foo = "bar"
return report def main(argv=None): 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()
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 chkpt are saved') flags.DEFINE_string('teachers_dir','/tmp/train_dir', 'Directory where teachers checkpoints are stored.') flags.DEFINE_integer('teachers_max_steps', 3000, """Number of steps teachers were ran.""") flags.DEFINE_integer('max_steps', 3000, """Number of steps to run student.""") flags.DEFINE_integer('nb_teachers', 10, """Teachers in the ensemble.""") tf.app.flags.DEFINE_integer('stdnt_share', 1000, """Student share (last index) of the test data""") flags.DEFINE_integer('lap_scale', 10, """Scale of the Laplacian noise added for privacy""") flags.DEFINE_boolean('save_labels', False, """Dump numpy arrays of labels and clean teacher votes""") flags.DEFINE_boolean('deeper', False, """Activate deeper CNN model""") def ensemble_preds(dataset, nb_teachers, stdnt_data): """ Given a dataset, a number of teachers, and some input data, this helper function queries each teacher for predictions on the data and returns all predictions in a single array. (That can then be aggregated into one single prediction per input using aggregation.py (cf. function prepare_student_data() below) :param dataset: string corresponding to mnist, cifar10, or svhn :param nb_teachers: number of teachers (in the ensemble) to learn from :param stdnt_data: unlabeled student training data :return: 3d array (teacher id, sample id, probability per class)
flags.DEFINE_float('meta_lr', 1e-12, 'the base learning rate of the generator') flags.DEFINE_integer( 'pretrain_iterations', 5600, 'number of pre-training iterations.') flags.DEFINE_integer( 'metatrain_iterations', 1, 'number of metatraining iterations.') flags.DEFINE_integer('feed_length', 3, 'length of days to feed') flags.DEFINE_string( 'logdir', '', 'directory for summaries and checkpoints.') flags.DEFINE_integer('test_iter', -1, 'iteration to load model (-1 for latest model)') flags.DEFINE_boolean('resume', False,'resume or not') flags.DEFINE_integer('num_updates',5,'number of updates') def train(model, saver, sess, exp_string, data_generator, resume_itr): SUMMARY_INTERVAL = 500 SAVE_INTERVAL = 1000 PRINT_INTERVAL = 500 TEST_PRINT_INTERVAL = PRINT_INTERVAL * 5 print('Done initializing') prelosses, postlosses = [], [] inputs, lables = data_generator.generate_time_series_batch(train=True) for itr in range( resume_itr, FLAGS.pretrain_iterations + FLAGS.metatrain_iterations):