'The width of the value conv layer.')
flags.DEFINE_integer('fc_width', 256 if go.N == 19 else 64,
'The width of the fully connected layer in value head.')
flags.DEFINE_integer('trunk_layers', go.N,
'The number of resnet layers in the shared trunk.')
flags.DEFINE_multi_integer(
'lr_boundaries', [400000, 600000],
'The number of steps at which the learning rate will decay')
flags.DEFINE_multi_float('lr_rates', [0.01, 0.001, 0.0001],
'The different learning rates')
flags.DEFINE_float('l2_strength', 1e-4,
'The L2 regularization parameter applied to weights.')
flags.DEFINE_float(
'value_cost_weight', 1.0,
'Scalar for value_cost, AGZ paper suggests 1/100 for '
'supervised learning')
flags.DEFINE_float('sgd_momentum', 0.9,
'Momentum parameter for learning rate.')
flags.DEFINE_string(
'work_dir', None, 'The Estimator working directory. Used to dump: '
'checkpoints, tensorboard logs, etc..')
flags.DEFINE_bool('use_tpu', False, 'Whether to use TPU for training.')
'Set:Get key pattern. G for Gaussian distribution, R for '
'uniform Random, S for Sequential. Defaults to R:R.')
MEMTIER_LOAD_KEY_MAXIMUM = flags.DEFINE_integer(
'memtier_load_key_maximum', None, 'Key ID maximum value to load. '
'The range of keys will be from 1 (min) to this specified max key value. '
'If not set, defaults to memtier_key_maximum. Setting this different from '
'memtier_key_maximum allows triggering of eviction behavior.')
MEMTIER_KEY_MAXIMUM = flags.DEFINE_integer(
'memtier_key_maximum', 10000000, 'Key ID maximum value. The range of keys '
'will be from 1 (min) to this specified max key value.')
MEMTIER_LATENCY_CAPPED_THROUGHPUT = flags.DEFINE_bool(
'latency_capped_throughput', False,
'Measure latency capped throughput. Use in conjunction with '
'memtier_latency_cap. Defaults to False. ')
MEMTIER_LATENCY_CAP = flags.DEFINE_float(
'memtier_latency_cap', 1.0, 'Latency cap in ms. Use in conjunction with '
'latency_capped_throughput. Defaults to 1ms.')
MEMTIER_RUN_MODE = flags.DEFINE_enum(
'memtier_run_mode', MemtierMode.NORMAL_RUN, MemtierMode.ALL,
'Mode that the benchmark is set to. NORMAL_RUN measures latency and '
'throughput, MEASURE_CPU_LATENCY measures single threaded latency at '
'memtier_cpu_target. When measuring CPU latency flags for '
'clients, threads, and pipelines are ignored and '
'memtier_cpu_target and memtier_cpu_duration must not '
'be None.')
MEMTIER_CPU_TARGET = flags.DEFINE_float(
'memtier_cpu_target', 0.5,
'The target CPU utilization when running memtier and trying to get the '
'latency at variable CPU metric. The target can range from 1%-100% and '
'represents the percent CPU utilization (e.g. 0.5 -> 50% CPU utilization)')
MEMTIER_CPU_DURATION = flags.DEFINE_integer(
from typing import Any, Dict, List
from absl import flags
from perfkitbenchmarker import benchmark_spec
from perfkitbenchmarker import configs
from perfkitbenchmarker import linux_packages
from perfkitbenchmarker import regex_util
from perfkitbenchmarker import sample
from perfkitbenchmarker import virtual_machine
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.linux_packages import cuda_toolkit
from perfkitbenchmarker.linux_packages import xgboost
_TREE_METHOD = flags.DEFINE_enum(
'xgboost_tree_method', 'gpu_hist', ['gpu_hist', 'hist'],
'XGBoost builtin tree methods.')
_SPARSITY = flags.DEFINE_float(
'xgboost_sparsity', 0.0, 'XGBoost sparsity-aware split finding algorithm.')
_ROWS = flags.DEFINE_integer(
'xgboost_rows', 1000000, 'The number of data rows.')
_COLUMNS = flags.DEFINE_integer(
'xgboost_columns', 50, 'The number of data columns.')
_ITERATIONS = flags.DEFINE_integer(
'xgboost_iterations', 500, 'The number of training iterations.')
_TEST_SIZE = flags.DEFINE_float(
'xgboost_test_size', 0.25,
'Train-test split for evaluating machine learning algorithms')
_PARAMS = flags.DEFINE_string(
'xgboost_params', None,
'Provide additional parameters as a Python dict string, '
'e.g. --params \"{\'max_depth\':2}\"')
"gradient_clip_norm": 5.,
"epochs": 100,
# that magic number
"seed": 42
}
# one-shot evaluation (and validation) options
flags.DEFINE_integer("episodes", 400, "number of L-way K-shot learning episodes")
flags.DEFINE_integer("L", 10, "number of classes to sample in a task episode (L-way)")
flags.DEFINE_integer("K", 1, "number of task learning samples per class (K-shot)")
flags.DEFINE_integer("N", 15, "number of task evaluation samples")
flags.DEFINE_integer("k_neighbours", 1, "number of nearest neighbours to consider")
flags.DEFINE_string("metric", "cosine", "distance metric to use for nearest neighbours matching")
flags.DEFINE_integer("fine_tune_steps", None, "number of fine-tune gradient steps on one-shot data")
flags.DEFINE_float("fine_tune_lr", 1e-3, "learning rate for gradient descent fine-tune")
flags.DEFINE_enum("speaker_mode", "baseline", ["baseline", "difficult", "distractor"],
"type of speakers selected in a task episode")
flags.DEFINE_bool("direct_match", True, "directly match speech to images")
flags.DEFINE_bool("unseen_match_set", False, "match set contains classes unseen in K-shot learning")
# model train/test options
flags.DEFINE_string("vision_base_dir", None, "directory containing base vision network model")
flags.DEFINE_string("audio_base_dir", None, "directory containing base audio network model")
flags.DEFINE_bool("l2_norm", True, "L2-normalise embedding predictions (as done in training)")
flags.DEFINE_bool("load_best", False, "load previous best model for resumed training or testing")
flags.DEFINE_bool("mc_dropout", False, "make embedding predictions with MC Dropout")
# TODO optional train from scratch or fine-tune base model?
# flags.DEFINE_bool("use_embeddings", False, "train on extracted embeddings from base model"
# "(default loads base network ('<best_>model.h5') and fine-tunes siamese loss)")
def define_deep_speech_flags():
"""Add flags for run_deep_speech."""
# Add common flags
flags_core.define_base(
data_dir=False, # we use train_data_dir and eval_data_dir instead
export_dir=True,
train_epochs=True,
hooks=True,
epochs_between_evals=True,
)
flags_core.define_performance(num_parallel_calls=False,
inter_op=False,
intra_op=False,
synthetic_data=False,
max_train_steps=False,
dtype=False)
flags_core.define_benchmark()
flags.adopt_module_key_flags(flags_core)
flags_core.set_defaults(model_dir=_DEFAULT_MODEL_DIR,
export_dir=_DEFAULT_SAVE_MODEL_DIR,
train_epochs=10,
batch_size=128,
hooks=[],
epochs_between_evals=4)
# Deep speech flags
flags.DEFINE_integer(name="seed",
default=1,
help=flags_core.help_wrap("The random seed."))
flags.DEFINE_string(
name="train_data_dir",
default=_DEFAULT_TRAIN_DIR,
help=flags_core.help_wrap("The csv file path of train dataset."))
flags.DEFINE_string(
name="eval_data_dir",
default=_DEFAULT_EVAL_DIR,
help=flags_core.help_wrap("The csv file path of evaluation dataset."))
flags.DEFINE_bool(
name="sortagrad",
default=True,
help=flags_core.help_wrap(
"If true, sort examples by audio length and perform no "
"batch_wise shuffling for the first epoch."))
flags.DEFINE_integer(
name="sample_rate",
default=16000,
help=flags_core.help_wrap("The sample rate for audio."))
flags.DEFINE_integer(
name="window_ms",
default=20,
help=flags_core.help_wrap("The frame length for spectrogram."))
flags.DEFINE_integer(name="stride_ms",
default=10,
help=flags_core.help_wrap("The frame step."))
flags.DEFINE_string(
name="vocabulary_file",
default=_DEFAULT_CHARACTERS_FILE,
help=flags_core.help_wrap("The file path of vocabulary file."))
# RNN related flags
flags.DEFINE_integer(name="rnn_hidden_size",
default=800,
help=flags_core.help_wrap("The hidden size of RNNs."))
flags.DEFINE_integer(
name="rnn_hidden_layers",
default=5,
help=flags_core.help_wrap("The number of RNN layers."))
flags.DEFINE_bool(name="use_bias",
default=True,
help=flags_core.help_wrap(
"Use bias in the last fully-connected layer"))
flags.DEFINE_bool(
name="is_bidirectional",
default=True,
help=flags_core.help_wrap("If rnn unit is bidirectional"))
flags.DEFINE_enum(name="rnn_type",
default="gru",
enum_values=deep_speech.SUPPORTED_RNNS.keys(),
case_sensitive=False,
help=flags_core.help_wrap("Type of RNN cell."))
# Training related flags
flags.DEFINE_float(name="learning_rate",
default=5e-4,
help=flags_core.help_wrap("The initial learning rate."))
# Evaluation metrics threshold
flags.DEFINE_float(
name="wer_threshold",
default=None,
help=flags_core.help_wrap(
"If passed, training will stop when the evaluation metric WER is "
"greater than or equal to wer_threshold. For libri speech dataset "
"the desired wer_threshold is 0.23 which is the result achieved by "
"MLPerf implementation."))
flags.DEFINE_integer(name='num_gpus', default=-1, help='num_gpus')
flags.DEFINE_integer("train_batch_size", 32, "Total batch size for training.")
flags.DEFINE_integer("eval_batch_size", 32, "Total batch size for eval.")
flags.DEFINE_integer("epochs", 5, "Total epochs.")
flags.DEFINE_integer("train_data_size", 10000, "The number of examples in the"
"training data")
flags.DEFINE_integer("eval_data_size", -1, "The number of examples in the"
"validation data")
flags.DEFINE_integer("predict_batch_size", 8, "Total batch size for predict.")
flags.DEFINE_float("learning_rate", 5e-5,
"The initial learning rate for Adam.")
flags.DEFINE_float(
"warmup_proportion", 0.1,
"Proportion of training to perform linear learning rate warmup for. "
"E.g., 0.1 = 10% of training.")
flags.DEFINE_integer("save_checkpoints_steps", 10000,
"How often to save the model checkpoint.")
flags.DEFINE_integer("iterations_per_loop", 1000,
"How many steps to make in each estimator call.")
flags.DEFINE_bool("use_tpu", False, "Whether to use TPU or GPU/CPU.")
flags.DEFINE_string(
return ops
def main(argv):
del argv # Unused.
batch = FLAGS.batch
dataset = data.get_dataset(FLAGS.dataset, dict(batch_size=batch))
scales = int(round(math.log(dataset.width // FLAGS.latent_width, 2)))
model = AAE(dataset,
FLAGS.train_dir,
latent=FLAGS.latent,
depth=FLAGS.depth,
scales=scales,
adversary_lr=FLAGS.adversary_lr,
disc_layer_sizes=FLAGS.disc_layer_sizes)
model.train()
if __name__ == '__main__':
flags.DEFINE_integer('depth', 64, 'Depth of first for convolution.')
flags.DEFINE_integer(
'latent', 16,
'Latent space depth, the total latent size is the depth multiplied by '
'latent_width ** 2.')
flags.DEFINE_integer('latent_width', 4, 'Width of the latent space.')
flags.DEFINE_float('adversary_lr', 1e-4,
'Learning rate for discriminator.')
flags.DEFINE_string('disc_layer_sizes', '100,100',
'Comma-separated list of discriminator layer sizes.')
app.run(main)
flags.DEFINE_integer("n_steps_per_batch", 8, "Number of steps per batch")
flags.DEFINE_integer("all_summary_freq", 50,
"Record all summaries every n batch")
flags.DEFINE_integer("scalar_summary_freq", 5,
"Record scalar summaries every n batch")
flags.DEFINE_string("checkpoint_path", "_files/models",
"Path for agent checkpoints")
flags.DEFINE_string("summary_path", "_files/summaries",
"Path for tensorboard summaries")
flags.DEFINE_string("model_name", "temp_testing",
"Name for checkpoints and tensorboard summaries")
flags.DEFINE_integer(
"K_batches", -1,
"Number of training batches to run in thousands, use -1 to run forever")
flags.DEFINE_string("map_name", "MoveToBeacon", "Name of a map to use.")
flags.DEFINE_float("discount", 0.95, "Reward-discount for the agent")
flags.DEFINE_boolean(
"training", True,
"if should train the model, if false then save only episode score summaries"
)
flags.DEFINE_enum(
"if_output_exists", "fail", ["fail", "overwrite", "continue"],
"What to do if summary and model output exists, only for training, is ignored if notraining"
)
flags.DEFINE_float("max_gradient_norm", 500.0,
"good value might depend on the environment")
flags.DEFINE_float("loss_value_weight", 1.0,
"good value might depend on the environment")
flags.DEFINE_float("entropy_weight_spatial", 1e-6,
"entropy of spatial action distribution loss weight")
flags.DEFINE_float("entropy_weight_action", 1e-6,
FLAGS = flags.FLAGS
# TODO(gnegiar): Use return values from flags.
flags.DEFINE_enum('dataset', 'mnist', ['mnist', 'lra_pathfinder'],
'which dataset to use')
flags.DEFINE_enum('pathfinder_difficulty', 'easy', ['easy', 'hard'],
'The level of difficulty for the pathfinder dataset.')
flags.DEFINE_integer('pathfinder_resolution', 32,
'Resolution for the pathfinder task.')
flags.DEFINE_integer('batch_size', 128, 'Training batch size')
flags.DEFINE_integer('log_freq', 10,
'Log batch accuracy and loss every log_freq iterations.')
flags.DEFINE_integer('n_epochs', 5, 'Number of training epochs.')
flags.DEFINE_float(
'alpha', .1,
'Probability of teleporting back to initial node distribution.')
flags.DEFINE_float('rho', 1e-3, 'L1 regularization in sparse PageRank.')
flags.DEFINE_integer('patch_size',
5,
'Size of the patch used to compute node features.',
lower_bound=1)
flags.DEFINE_enum('optimizer', 'adam', ['adam', 'sgd'], 'optimizer to use')
flags.DEFINE_float('learning_rate', 1e-2, 'Learning rate for the optimizer.')
flags.DEFINE_string(
'tensorboard_logdir', None,
'Path to directory where tensorboard summaries are stored.')
flags.DEFINE_bool(
'use_node_weights', True,
'Whether to use the learned node weights in the downstream graph model.')
flags.DEFINE_integer('max_subgraph_size', 100,
"""
A cartpole learning example with OpenAI gym
===========================================
This example illustrates how to use `OpenAI Gym <https://gym.openai.com/>`_ to
train a cartpole task.
"""
import norse.task.cartpole as cartpole
from absl import app
from absl import flags
flags.DEFINE_enum("device", "cpu", ["cpu", "cuda"], "Device to use by pytorch.")
flags.DEFINE_integer("episodes", 100, "Number of training trials.")
flags.DEFINE_float("learning_rate", 1e-3, "Learning rate to use.")
flags.DEFINE_float("gamma", 0.99, "discount factor to use")
flags.DEFINE_integer(
"log_interval", 10, "In which intervals to display learning progress."
)
flags.DEFINE_enum("model", "super", ["super"], "Model to use for training.")
flags.DEFINE_enum("policy", "snn", ["snn", "lsnn", "ann"], "Select policy to use.")
flags.DEFINE_boolean("render", False, "Render the environment")
flags.DEFINE_string("environment", "CartPole-v1", "Gym environment to use.")
flags.DEFINE_integer("random_seed", 1234, "Random seed to use")
def main():
app.run(cartpole.main)
if __name__ == "__main__":
main()
sys.path.append(os.path.abspath(os.path.join(os.getcwd(), "..")))
from utils.process_wav import wav2fb
from utils.split_data import split_data
root_dir = os.path.abspath(os.path.join(os.getcwd(), "../.."))
FLAGS = flags.FLAGS
flags.DEFINE_string("data_dir",
os.path.join(root_dir, "data/vad_data"),
help="the vad data dir")
flags.DEFINE_string("save_dir",
os.path.join(root_dir, "data/bin"),
help="save fbank vector dir")
flags.DEFINE_string("category", "test", help="the category of data")
flags.DEFINE_float("validata_scale", 0.05, help="the scale of validate data")
def main(argv):
# 分割数据集
train_list, validate_list = split_data(FLAGS.data_dir, FLAGS.category,
FLAGS.validata_scale)
# 将特征向量存入 bin 文件中
# 处理训练数据 分为训练集和验证集
if FLAGS.validata_scale > 0:
wav2fb(train_list, os.path.abspath(FLAGS.save_dir), "train")
wav2fb(validate_list, os.path.abspath(FLAGS.save_dir), "validate")
# 处理注册和验证时的数据 validata_scale=0
else:
wav2fb(train_list, os.path.abspath(FLAGS.save_dir), FLAGS.category)
FLAGS = flags.FLAGS
flags.DEFINE_string('file_pattern', None, 'Dataset location.')
flags.DEFINE_string('sk', None, 'Samples name.')
flags.DEFINE_alias('samples_key', 'sk')
flags.DEFINE_integer('ml', 16000, 'Minimum length.')
flags.DEFINE_alias('min_length', 'ml')
flags.DEFINE_string('label_key', None, 'Name of label to use.')
flags.DEFINE_list('label_list', None, 'List of possible label values.')
flags.DEFINE_integer('batch_size', None, 'The number of images in each batch.')
flags.DEFINE_integer('tbs', None, 'not used')
flags.DEFINE_integer('nc', None, 'num_clusters')
flags.DEFINE_float('alpha_init', None, 'Initial autopool alpha.')
flags.DEFINE_alias('ai', 'alpha_init')
flags.DEFINE_boolean('ubn', None, 'Whether to normalize')
flags.DEFINE_float('lr', None, 'not used')
flags.DEFINE_string('logdir', None,
'Directory where the model was written to.')
flags.DEFINE_string('eval_dir', None,
'Directory where the results are saved to.')
flags.DEFINE_integer('take_fixed_data', None,
'If not `None`, take a fixed number of data elements.')
flags.DEFINE_integer('timeout', 7200, 'Wait-for-checkpoint timeout.')
flags.DEFINE_boolean(
'calculate_equal_error_rate', False,
'Whether to calculate the Equal Error Rate. Only '
from deep_contextual_bandits import neural_linear_sampling # local file import
from deep_contextual_bandits import posterior_bnn_sampling # local file import
from deep_contextual_bandits import uniform_sampling # local file import
from tensorflow.contrib import training as contrib_training
gfile = tf.compat.v1.gfile
tf.compat.v1.enable_eager_execution()
FLAGS = flags.FLAGS
FLAGS.set_default('alsologtostderr', True)
flags.DEFINE_string('logdir', '/tmp/bandits/',
'Base directory to save output.')
flags.DEFINE_integer('trial_idx', 0, 'Rerun idx of problem instance.')
flags.DEFINE_float('delta', 0.5, 'delta parameter for wheel bandit instance.')
flags.DEFINE_string('modeldir', '/tmp/wheel_bandit/models/multitask',
'Directory with pretrained models.')
flags.DEFINE_string('savedir', '/tmp/wheel_bandit/results/',
'Directory with saved pkl files for full results.')
flags.DEFINE_string('ckptdir', '/tmp/wheel_bandit/ckpts/',
'Directory with saved pkl files for full ckpts.')
flags.DEFINE_string('datasetdir', '/tmp/wheel_bandit/data/',
'Directory with saved data instances.')
flags.DEFINE_integer('exp_idx', 0, 'Experiment idx of full run.')
flags.DEFINE_string('prefix', 'best_', 'Prefix of best model ckpts.')
flags.DEFINE_string('suffix', '_mse.ckpt', 'Suffix of best model ckpts.')
flags.DEFINE_list('algo_names', ['uniform', 'snp_posterior_gp_offline'],
'List of algorithms to benchmark.')
context_dim = 2
flags.DEFINE_string(
'hparams', '', 'Comma separated k=v pairs of hyperparameters or a module'
' containing attributes to use as hyperparameters.')
flags.DEFINE_string('input_image', None, 'Input image path for inference.')
flags.DEFINE_string('output_image_dir', None, 'Output dir for inference.')
# For video.
flags.DEFINE_string('input_video', None, 'Input video path for inference.')
flags.DEFINE_string('output_video', None,
'Output video path. If None, play it online instead.')
# For visualization.
flags.DEFINE_integer('line_thickness', None, 'Line thickness for box.')
flags.DEFINE_integer('max_boxes_to_draw', None, 'Max number of boxes to draw.')
flags.DEFINE_float('min_score_thresh', None, 'Score threshold to show box.')
# For saved model.
flags.DEFINE_string('saved_model_dir', '/tmp/saved_model',
'Folder path for saved model.')
flags.DEFINE_string('tflite_path', None, 'Path for exporting tflite file.')
FLAGS = flags.FLAGS
class ModelInspector(object):
"""A simple helper class for inspecting a model."""
def __init__(self,
model_name: Text,
logdir: Text,
"List of (string) path(s) to evaluation file(s).")
# # If the model has an adversary, the features for adversary are constructed
# # in the corresponding custom estimator implementation by filtering feature_columns passed to the learner.
flags.DEFINE_bool(
"include_sensitive_columns", False,
"Set the flag to include protected features in the feature_columns of the learner."
)
# Flags for setting common model parameters for all approaches
flags.DEFINE_multi_integer("primary_hidden_units", [64, 32],
"Hidden layer sizes of main learner.")
flags.DEFINE_integer("embedding_dimension", 32,
"Embedding size; if 0, use one hot.")
flags.DEFINE_integer("batch_size", 32, "Batch size.")
flags.DEFINE_float("primary_learning_rate", 0.001,
"learning rate for main learner.")
flags.DEFINE_string("optimizer", "Adagrad", "Name of the optimizer to use.")
flags.DEFINE_string("activation", "relu", "Name of the activation to use.")
# # Flags for approaches that have an adversary
# # Currently only for ''adversarial_reweighting'' Model.
flags.DEFINE_multi_integer("adversary_hidden_units", [32],
"Hidden layer sizes of adversary.")
flags.DEFINE_float("adversary_learning_rate", 0.001,
"learning rate for adversary.")
# # Flags for adversarial_reweighting model
flags.DEFINE_string(
"adversary_loss_type", "ce_loss",
"Type of adversary loss function to be used. Takes values in [``ce_loss'',''hinge_loss'']. ``ce loss`` stands for cross-entropy loss"
)
"""
import collections
import math
from absl import flags
import numpy as np
import coords
import go
# 722 moves for 19x19, 162 for 9x9
flags.DEFINE_integer('max_game_length', int(go.N ** 2 * 2),
'Move number at which game is forcibly terminated')
flags.DEFINE_float('c_puct_base', 19652,
'Exploration constants balancing priors vs. value net output.')
flags.DEFINE_float('c_puct_init', 1.25,
'Exploration constants balancing priors vs. value net output.')
flags.DEFINE_float('dirichlet_noise_alpha', 0.03 * 361 / (go.N ** 2),
'Concentrated-ness of the noise being injected into priors.')
flags.register_validator('dirichlet_noise_alpha', lambda x: 0 <= x < 1)
flags.DEFINE_float('dirichlet_noise_weight', 0.25,
'How much to weight the priors vs. dirichlet noise when mixing')
flags.register_validator('dirichlet_noise_weight', lambda x: 0 <= x < 1)
FLAGS = flags.FLAGS
import scipy.io as sio
from collections import OrderedDict
from ..data import cub as cub_data
from ..utils import visutil
from ..utils import bird_vis
from ..utils import image as image_utils
from ..nnutils import train_utils
from ..nnutils import loss_utils
from ..nnutils import mesh_net
from ..nnutils.nmr import NeuralRenderer
from ..nnutils import geom_utils
flags.DEFINE_string('dataset', 'cub', 'cub or pascal or p3d')
# Weights:
flags.DEFINE_float('kp_loss_wt', 30., 'keypoint loss weight')
flags.DEFINE_float('mask_loss_wt', 2., 'mask loss weight')
flags.DEFINE_float('cam_loss_wt', 2., 'weights to camera loss')
flags.DEFINE_float('deform_reg_wt', 10., 'reg to deformation')
flags.DEFINE_float('triangle_reg_wt', 30.,
'weights to triangle smoothness prior')
flags.DEFINE_float('vert2kp_loss_wt', .16, 'reg to vertex assignment')
flags.DEFINE_float('tex_loss_wt', .5, 'weights to tex loss')
flags.DEFINE_float('tex_dt_loss_wt', .5, 'weights to tex dt loss')
flags.DEFINE_boolean(
'use_gtpose', True,
'if true uses gt pose for projection, but camera still gets trained.')
flags.DEFINE_boolean('include_weighted', False,
'if True, include weighted loss values to loss output')
opts = flags.FLAGS
from __future__ import print_function
from absl import app
from absl import flags
import tensorflow.compat.v2 as tf
from tensorflow.examples.saved_model.integration_tests import mnist_util
from tensorflow.examples.saved_model.integration_tests import util
FLAGS = flags.FLAGS
flags.DEFINE_string('export_dir', None, 'Directory of exported SavedModel.')
flags.DEFINE_integer('epochs', 5, 'Number of epochs to train.')
flags.DEFINE_bool('retrain', False,
'If set, the imported SavedModel is trained further.')
flags.DEFINE_float('dropout_rate', None,
'If set, dropout rate passed to the SavedModel.')
flags.DEFINE_float(
'regularization_loss_multiplier', None,
'If set, multiplier for the regularization losses in the SavedModel.')
flags.DEFINE_bool(
'use_fashion_mnist', False,
'Use Fashion MNIST (products) instead of the real MNIST (digits). '
'With this, --retrain gains a lot.')
flags.DEFINE_bool('fast_test_mode', False,
'Shortcut training for running in unit tests.')
def make_classifier(feature_extractor, l2_strength=0.01, dropout_rate=0.5):
"""Returns a Keras Model to classify MNIST using feature_extractor."""
regularizer = lambda: tf.keras.regularizers.l2(l2_strength)
net = inp = tf.keras.Input(mnist_util.INPUT_SHAPE)
from dice_rl.google.estimators.tabular_qlearning import TabularQLearning
from dice_rl.estimators import estimator as estimator_lib
import dice_rl.utils.common as common_utils
from dice_rl.data.dataset import Dataset, EnvStep, StepType
from dice_rl.data.tf_offpolicy_dataset import TFOffpolicyDataset
import google3.learning.deepmind.xmanager2.client.google as xm # pylint: disable=unused-import
FLAGS = flags.FLAGS
flags.DEFINE_string('env_name', 'taxi', 'Environment name.')
flags.DEFINE_integer('seed', 0, 'Initial random seed.')
flags.DEFINE_integer('num_trajectory', 100,
'Number of trajectories to collect.')
flags.DEFINE_integer('max_trajectory_length', 500,
'Cutoff trajectory at this step.')
flags.DEFINE_float('alpha', 0.0, 'How close to target policy.')
flags.DEFINE_bool('tabular_obs', True, 'Whether to use tabular observations.')
#flags.DEFINE_string('load_dir', '/cns/is-d/home/sherryy/teqdice/data',
flags.DEFINE_string('load_dir', '/cns/vz-d/home/brain-ofirnachum',
'Directory to load dataset from.')
flags.DEFINE_string('save_dir', None, 'Directory to save estimation results.')
flags.DEFINE_float('gamma', 0.995, 'Discount factor.')
flags.DEFINE_integer('limit_episodes', None,
'Number of episodes to take from dataset.')
def main(argv):
env_name = FLAGS.env_name
seed = FLAGS.seed
tabular_obs = FLAGS.tabular_obs
num_trajectory = FLAGS.num_trajectory
from absl import flags
# Dataset/training options
flags.DEFINE_integer('seed', 1, 'Random seed.')
flags.DEFINE_integer('batch_size', 32, 'Batch size per TPU Core / GPU')
flags.DEFINE_float('base_learning_rate', 3.2e-04, 'base learning rate at the start of training session')
flags.DEFINE_integer('lr_warmup_epochs', 1, 'No. of epochs for a warmup to the base_learning_rate. 0 for no warmup')
flags.DEFINE_float('lr_drop_ratio', 0.8, 'Amount to decay the learning rate')
flags.DEFINE_bool('custom_decay_lr', False, 'Whether to specify epochs to decay learning rate.')
flags.DEFINE_list('lr_decay_epochs', [10, 20, 40, 60], 'Epochs to decay the learning rate by. Only used if custom_decay_lr is True')
flags.DEFINE_string('dataset', 'oai_challenge', 'Dataset: oai_challenge, isic_2018 or oai_full')
flags.DEFINE_bool('use_2d', True, 'True to train on 2D slices, False to train on 3D data')
flags.DEFINE_integer('train_epochs', 50, 'Number of training epochs.')
flags.DEFINE_string('aug_strategy', None, 'Augmentation Strategies: None, random-crop, noise, crop_and_noise')
# Model options
flags.DEFINE_string('model_architecture', 'unet', 'unet, r2unet, segnet, unet++, 100-Layer-Tiramisu, deeplabv3, deeplabv3_plus')
flags.DEFINE_integer('buffer_size', 5000, 'shuffle buffer size')
flags.DEFINE_bool('multi_class', True, 'Whether to train on a multi-class (Default) or binary setting')
flags.DEFINE_integer('kernel_size', 3, 'kernel size to be used')
flags.DEFINE_bool('use_batchnorm', True, 'Whether to use batch normalisation')
flags.DEFINE_bool('use_bias', True, 'Wheter to use bias')
flags.DEFINE_string('channel_order', 'channels_last', 'channels_last (Default) or channels_first')
flags.DEFINE_string('activation', 'relu', 'activation function to be used')
flags.DEFINE_bool('use_dropout', False, 'Whether to use dropout')
flags.DEFINE_bool('use_spatial', False, 'Whether to use spatial Dropout. Only used if use_dropout is True')
flags.DEFINE_float('dropout_rate', 0.0, 'Dropout rate. Only used if use_dropout is True')
flags.DEFINE_string('optimizer', 'adam', 'Which optimizer to use for model: adam, rmsprop, sgd')
# UNet parameters
flags.DEFINE_list('num_filters', [64, 128, 256, 512, 1024], 'number of filters in the model')
FLAGS = flags.FLAGS
# Basic run settings
flags.DEFINE_enum("mode",
default='train',
enum_values=['train', 'test', 'inference_benchmark'],
help="Select task to be performed")
flags.DEFINE_integer("seed", 12345, "Random seed")
# Training schedule flags
flags.DEFINE_integer("batch_size", 32768, "Batch size used for training")
flags.DEFINE_integer("test_batch_size", 32768,
"Batch size used for testing/validation")
flags.DEFINE_float("lr", 28, "Base learning rate")
flags.DEFINE_integer("epochs", 1, "Number of epochs to train for")
flags.DEFINE_integer("max_steps", None,
"Stop training after doing this many optimization steps")
flags.DEFINE_integer(
"warmup_factor", 0,
"Learning rate warmup factor. Must be a non-negative integer")
flags.DEFINE_integer("warmup_steps", 6400,
"Number of warmup optimization steps")
flags.DEFINE_integer(
"decay_steps", 80000,
"Polynomial learning rate decay steps. If equal to 0 will not do any decaying"
)
flags.DEFINE_integer(
"decay_start_step", 64000,
from __future__ import print_function
import functools
import json
import os
from absl import app
from absl import flags
from rdkit import Chem
from rdkit.Contrib.SA_Score import sascorer
from dqn import deep_q_networks
from dqn import molecules as molecules_mdp
from dqn import run_dqn
from dqn.tensorflow_core import core
flags.DEFINE_float('target_sas', 2.5,
'The target synthetic accessibility value')
flags.DEFINE_string('loss_type', 'l2', 'The loss type')
FLAGS = flags.FLAGS
class TargetSASMolecule(molecules_mdp.Molecule):
"""Target SAS reward Molecule."""
def __init__(self, discount_factor, target_sas, loss_type, **kwargs):
"""Initializes the class.
Args:
discount_factor: Float. The discount factor. We only care about the
molecule at the end of modification. In order to prevent a myopic
decision, we discount the reward at each step by a factor of
discount_factor ** num_steps_left, this encourages exploration with
emphasis on long term rewards.
'may elapse while no new checkpoints are observed')
flags.DEFINE_bool(
'use_tpu', True,
'Use TPUs rather than plain CPUs')
flags.DEFINE_boolean(
'per_host_input_for_training', True,
'If true, input_fn is invoked per host rather than per shard.')
flags.DEFINE_string(
'use_data', 'real',
'One of "fake","real"')
flags.DEFINE_float(
'learning_rate', 0.165,
'Learning rate.')
flags.DEFINE_float(
'depth_multiplier', 1.0,
'Depth Multiplier on Inception')
flags.DEFINE_string(
'optimizer', 'RMS',
'Optimizer (one of sgd, RMS, momentum)')
flags.DEFINE_integer(
'num_classes', 1001,
'Number of classes to distinguish')
flags.DEFINE_integer(
import os
import time
from absl import app
from absl import flags
from absl import logging
import tensorflow as tf
import tensorflow_datasets as tfds
import uncertainty_baselines as ub
import utils # local file import
import uncertainty_metrics as um
flags.DEFINE_integer('seed', 42, 'Random seed.')
flags.DEFINE_integer('per_core_batch_size', 64, 'Batch size per TPU core/GPU.')
flags.DEFINE_float(
'base_learning_rate', 0.1,
'Base learning rate when total batch size is 128. It is '
'scaled by the ratio of the total batch size to 128.')
flags.DEFINE_integer(
'lr_warmup_epochs', 1,
'Number of epochs for a linear warmup to the initial '
'learning rate. Use 0 to do no warmup.')
flags.DEFINE_float('lr_decay_ratio', 0.2, 'Amount to decay learning rate.')
flags.DEFINE_list('lr_decay_epochs', ['60', '120', '160'],
'Epochs to decay learning rate by.')
flags.DEFINE_integer('kl_annealing_epochs', 200,
'Number of epoch over which to anneal the KL term to 1.')
flags.DEFINE_float('l2', 4e-4, 'L2 regularization coefficient.')
flags.DEFINE_float('prior_stddev', 0.1, 'Fixed stddev for weight prior.')
flags.DEFINE_float(
'stddev_init', 1e-3,
'Initialization of posterior standard deviation parameters.')
flags.DEFINE_integer("char_limit", 16, "Limit length for character")
flags.DEFINE_integer("word_count_limit", -1, "Min count for word")
flags.DEFINE_integer("char_count_limit", -1, "Min count for char")
flags.DEFINE_integer("capacity", 15000, "Batch size of dataset shuffle")
flags.DEFINE_integer("num_threads", 4, "Number of threads in input pipeline")
flags.DEFINE_boolean("is_bucket", False, "build bucket batch iterator or not")
flags.DEFINE_list("bucket_range", [40, 401, 40], "the range of bucket")
flags.DEFINE_integer("batch_size", 32, "Batch size")
flags.DEFINE_integer("num_steps", 60000, "Number of steps")
flags.DEFINE_integer("checkpoint", 1000, "checkpoint to save and evaluate the model")
flags.DEFINE_integer("period", 100, "period to save batch loss")
flags.DEFINE_integer("val_num_batches", 150, "Number of batches to evaluate the model")
flags.DEFINE_integer("test_num_batches", 150, "Number of batches to evaluate the model")
flags.DEFINE_float("dropout", 0.1, "Dropout prob across the layers")
flags.DEFINE_float("dropout_char", 0.05, "Dropout prob across the layers")
flags.DEFINE_float("grad_clip", 5.0, "Global Norm gradient clipping rate")
flags.DEFINE_float("learning_rate", 0.001, "Learning rate")
flags.DEFINE_integer("lr_warm_up_num", 1000, "Number of warm-up steps of learning rate")
flags.DEFINE_float("decay", 0.9999, "Exponential moving average decay")
flags.DEFINE_float("beta1", 0.8, "Beta 1")
flags.DEFINE_float("beta2", 0.999, "Beta 2")
# flags.DEFINE_float("l2_norm", 3e-7, "L2 norm scale")
flags.DEFINE_integer("early_stop", 10, "Checkpoints for early stop")
flags.DEFINE_integer("connector_dim", 128, "Dimension of connectors of each layer")
flags.DEFINE_integer("num_heads", 8, "Number of heads in multi-head attention")
# Extensions (Uncomment corresponding line in download.sh to download the required data)
glove_char_file = os.path.join(home, "data", "glove", "glove.840B.300d-char.txt")
flags.DEFINE_string("glove_char_file", glove_char_file, "Glove character embedding")
from absl import flags
from absl import logging
from seed_rl import grpc
from seed_rl.common import common_flags
from seed_rl.utils import utils
import tensorflow as tf
flags.DEFINE_integer('save_checkpoint_secs', 1800,
'Checkpoint save period in seconds.')
flags.DEFINE_integer('total_environment_frames', int(1e9),
'Total environment frames to train for.')
flags.DEFINE_integer('batch_size', 2, 'Batch size for training.')
flags.DEFINE_float(
'replay_ratio', 1.5,
'Average number of times each observation is replayed and '
'used for training. '
'The default of 1.5 corresponds to an interpretation of the '
'R2D2 paper using the end of section 2.3.')
flags.DEFINE_integer('inference_batch_size', 2, 'Batch size for inference.')
flags.DEFINE_integer('unroll_length', 100, 'Unroll length in agent steps.')
flags.DEFINE_integer('num_training_tpus', 1, 'Number of TPUs for training.')
flags.DEFINE_integer(
'update_target_every_n_step', 2500,
'Update the target network at this frequency (expressed '
'in number of training steps)')
flags.DEFINE_integer(
'replay_buffer_size', 100,
'Size of the replay buffer (in number of unrolls stored).')
flags.DEFINE_integer(
'replay_buffer_min_size', 10,
'Learning only starts when there is at least this number '
' for max parallelization.')
flags.DEFINE_integer(
'batch_size', 128,
'Batch size for detection: higher faster, but more memory intensive.')
flags.DEFINE_string(
'model',
'yolo',
# flags.DEFINE_string('model', 'frcnn',
'Model to use, either yolo or frcnn')
flags.DEFINE_integer('detect_every', 20,
'The frame interval to perform detection.')
flags.DEFINE_float(
'save_detection_threshold', 0.5,
'The threshold on detections to them being saved to the detection save file.'
)
# tracking params if needed
flags.DEFINE_float('track_detection_threshold', 0.5,
'The threshold on detections to them being tracked.')
flags.DEFINE_integer(
'max_age', 40,
'Maximum frames between detections before a track is deleted. Bigger means tracks handle'
'occlusions better but also might overstay their welcome.')
flags.DEFINE_integer(
'min_hits', 2,
'Minimum number of detections before a track is displayed.')
try:
app.run(main)
def define_hparams_flags():
flags.DEFINE_string(
'log_path',
default="./mrcnn.json",
help=(
'The path where dllogger json file will be saved. Please include the'
' name of the json file as well.'
)
)
flags.DEFINE_string(
'data_dir',
default=None,
help=(
'The directory where the input data is stored. Please see the model'
' specific README.md for the expected data format.'
)
)
flags.DEFINE_string('checkpoint', default='', help='Checkpoint filepath')
flags.DEFINE_integer(
'eval_batch_size',
default=8,
help='Batch size for evaluation.'
)
flags.DEFINE_bool(
'eval_after_training',
default=True,
help='Run one eval after the training finishes.'
)
flags.DEFINE_integer('eval_samples', default=5000, help='Number of training steps')
flags.DEFINE_bool(
'include_groundtruth_in_features',
default=False,
help=(
'If `val_json_file` is not provided, one can also read groundtruth'
' from input by setting `include_groundtruth_in_features`=True'
)
)
# Gradient clipping is a fairly coarse heuristic to stabilize training.
# This model clips the gradient by its L2 norm globally (i.e., across
# all variables), using a threshold obtained from multiplying this
# parameter with sqrt(number_of_weights), to have a meaningful value
# across both training phases and different sizes of imported modules.
# Refer value: 0.02, for 25M weights, yields clip norm 10.
# Zero or negative number means no clipping.
flags.DEFINE_float("global_gradient_clip_ratio", default=-1.0, help="Global Gradient Clipping Ratio")
flags.DEFINE_float("init_learning_rate", default=2.5e-3, help="Initial Learning Rate")
flags.DEFINE_float("warmup_learning_rate", default=0., help="Warmup Learning Rate Decay Factor")
flags.DEFINE_bool('finetune_bn', False, 'is batchnorm training mode')
flags.DEFINE_float("l2_weight_decay", default=1e-4, help="l2 regularization weight")
flags.DEFINE_string('mode', default='train_and_eval', help='Mode to run: train or eval')
flags.DEFINE_string(
'model_dir',
default=None,
help='The directory where the model and training/evaluation summaries are stored.'
)
flags.DEFINE_float("momentum", default=0.9, help="Optimizer Momentum")
flags.DEFINE_integer('num_steps_per_eval', default=2500, help='Number of steps per evaluation epoch.')
flags.DEFINE_integer('save_checkpoints_steps', default=2500, help='Save a checkpoint every N steps.')
flags.DEFINE_integer('seed', default=None, help='Set a debug seed for reproducibility.')
flags.DEFINE_integer('train_batch_size', default=2, help='Batch size for training.')
flags.DEFINE_integer(
'total_steps',
default=938240,
help=(
'The number of steps to use for training. This flag'
' should be adjusted according to the --train_batch_size flag.'
)
)
flags.DEFINE_list(
'learning_rate_decay_levels',
default=['0.1', '0.01'],
help=(
'The learning rate decay levels which modify the learning rate using the formula:'
' `lr = decay * init_lr`. Decay factor applied at learning_rate_steps.'
)
)
flags.DEFINE_list(
'learning_rate_steps',
default=['480000', '640000'],
help=(
'The steps at which learning rate changes. This flag'
' should be adjusted according to the --train_batch_size flag.'
)
)
flags.DEFINE_integer('warmup_steps', default=1000, help='The number of steps to use warmup learning rate for')
flags.DEFINE_bool('use_amp', default=False, help='Enable automatic mixed precision')
flags.DEFINE_bool(
'use_batched_nms',
default=False,
help='Enable Batched NMS at inference.'
)
flags.DEFINE_bool(
'use_custom_box_proposals_op',
default=False,
help='Use GenerateBoundingBoxProposals op.'
)
flags.DEFINE_bool('use_fake_data', False, 'Use fake input.')
flags.DEFINE_bool(
'use_tf_distributed',
default=False,
help='Use tensorflow distributed API'
)
flags.DEFINE_bool('use_xla', default=False, help='Enable XLA JIT Compiler.')
flags.DEFINE_string('training_file_pattern', default="", help='TFRecords file pattern for the training files')
flags.DEFINE_string('validation_file_pattern', default="", help='TFRecords file pattern for the validation files')
flags.DEFINE_string('val_json_file', default="", help='Filepath for the validation json file')
############################# TO BE REMOVED ###################################
flags.DEFINE_integer(
'report_frequency',
default=None,
help='The amount of batches in between accuracy reports at evaluation time'
)
############################# TO BE REMOVED ###################################
############################### ISSUES TO FIX - FLAGS #############################"
# TODO: Remove when XLA at inference fixed
flags.DEFINE_bool(
'allow_xla_at_inference',
default=False,
help='Enable XLA JIT Compiler at Inference'
)
return flags.FLAGS
}
loss_fns = {
'bce': losses.BCEWithLogits,
'hinge': losses.Hinge,
'was': losses.Wasserstein,
'softplus': losses.Softplus
}
FLAGS = flags.FLAGS
# model and training
flags.DEFINE_enum('dataset', 'cifar10', ['cifar10', 'stl10'], "dataset")
flags.DEFINE_enum('arch', 'cnn32', net_G_models.keys(), "architecture")
flags.DEFINE_integer('total_steps', 50000, "total number of training steps")
flags.DEFINE_integer('batch_size', 128, "batch size")
flags.DEFINE_float('lr_G', 2e-4, "Generator learning rate")
flags.DEFINE_float('lr_D', 2e-4, "Discriminator learning rate")
flags.DEFINE_multi_float('betas', [0.5, 0.9], "for Adam")
flags.DEFINE_integer('n_dis', 1, "update Generator every this steps")
flags.DEFINE_integer('z_dim', 100, "latent space dimension")
flags.DEFINE_enum('loss', 'bce', loss_fns.keys(), "loss function")
flags.DEFINE_integer('seed', 0, "random seed")
# logging
flags.DEFINE_integer('eval_step', 5000, "evaluate FID and Inception Score")
flags.DEFINE_integer('sample_step', 500, "sample image every this steps")
flags.DEFINE_integer('sample_size', 64, "sampling size of images")
flags.DEFINE_string('logdir', './logs/DCGAN_CIFAR10', 'logging folder')
flags.DEFINE_bool('record', True, "record inception score and FID score")
flags.DEFINE_string('fid_cache', './stats/cifar10_stats.npz', 'FID cache')
# generate
flags.DEFINE_bool('generate', False, 'generate images')
from tensor2tensor.layers import common_image_attention as cia
from tensor2tensor.layers import common_layers
from tensor2tensor.models import transformer
import tensorflow as tf
from tensorflow_probability import bijectors as tfb
from tensorflow_probability import distributions as tfd
from tensorflow.contrib.learn.python.learn.datasets import mnist
from tensorflow.python.training import moving_averages
# TODO(vafa): Set random seed.
IMAGE_SHAPE = [28, 28, 1]
INITIAL_SCALE_BIAS = np.log(np.e / 2. - 1., dtype=np.float32)
flags.DEFINE_float("learning_rate",
default=0.001,
help="Initial learning rate.")
flags.DEFINE_integer("max_steps",
default=10000,
help="Number of training steps to run.")
flags.DEFINE_integer("latent_size",
default=10,
help="Number of latent variables.")
flags.DEFINE_integer("num_codes",
default=64,
help="Number of discrete codes in codebook.")
flags.DEFINE_integer("code_size",
default=16,
help="Dimension of each entry in codebook.")
flags.DEFINE_integer("base_depth",
default=32,
