def set_global_determinism(seed=SEED, fast_n_close=False):
"""
Enable 100% reproducibility on operations related to tensor and randomness.
Parameters:
seed (int): seed value for global randomness
fast_n_close (bool): whether to achieve efficient at the cost of determinism/reproducibility
"""
set_seeds(seed=seed)
if fast_n_close:
return
logging.warning(
"*******************************************************************************"
)
logging.warning(
"*** set_global_determinism is called,setting full determinism, will be slow ***"
)
logging.warning(
"*******************************************************************************"
)
os.environ['TF_DETERMINISTIC_OPS'] = '1'
os.environ['TF_CUDNN_DETERMINISTIC'] = '1'
# https://www.tensorflow.org/api_docs/python/tf/config/threading/set_inter_op_parallelism_threads
tf.config.threading.set_inter_op_parallelism_threads(1)
tf.config.threading.set_intra_op_parallelism_threads(1)
from tfdeterminism import patch
patch()
def enable_deterministic_training(seed, no_gpu_patch=False):
"""Set all seeds for deterministic training
Args:
no_gpu_patch (bool): if False, apply a patch to TensorFlow to have
deterministic GPU operations, if True the training is much faster
but slightly less deterministic.
This function needs to be called before any TensorFlow code.
"""
import numpy as np
import os
import random
import tfdeterminism
if not no_gpu_patch:
# Patch stock TensorFlow to have deterministic GPU operation
tfdeterminism.patch() # then use tf as normal
# If PYTHONHASHSEED environment variable is not set or set to random,
# a random value is used to seed the hashes of str, bytes and datetime
# objects. (Necessary for Python >= 3.2.3)
os.environ['PYTHONHASHSEED'] = str(seed)
# Set python built-in pseudo-random generator at a fixed value
random.seed(seed)
# Set seed for random Numpy operation (e.g. np.random.randint)
np.random.seed(seed)
# Set seed for random TensorFlow operation (e.g. tf.image.random_crop)
tf.compat.v1.random.set_random_seed(seed)
def run(esetSC2, geneList, random_seed, hidden_size, hidden_size2,
code_sizeList, activ1, optim, noise_factor):
## to improve reproducibility
patch()
os.environ['PYTHONHASHSEED'] = str(random_seed)
config = tf.compat.v1.ConfigProto(intra_op_parallelism_threads=1,
inter_op_parallelism_threads=1)
session = tf.compat.v1.Session(config=config)
tf.compat.v1.keras.backend.set_session(session)
### genes from feature selection + autoencoder
esetSC2Var = esetSC2.loc[geneList]
## General Processing; original
esetSC2Var = esetSC2Var.values
esetSC2Var = esetSC2Var / np.max(esetSC2Var)
esetSC2Var = transpose(esetSC2Var)
## Prediction & Evaluation
random.seed(random_seed)
np.random.seed(random_seed)
auto_list = None
best_model_ind = None
## Denoising Autoencoder Preparation
esetSC2Var_noisy = esetSC2Var + noise_factor * np.random.normal(
size=esetSC2Var.shape)
esetSC2Var_noisy = np.clip(esetSC2Var_noisy, 0.0,
1.0) ## already transposed
evalOut = predEval(code_sizeList, esetSC2Var_noisy, esetSC2Var,
hidden_size, hidden_size2, activ1, optim, random_seed)
[
auto_list, abs_spearman, abs_pearson, abs_kendall, abs_eucDist,
scalarTestLoss
] = evalOut
bests = [abs_spearman.index(max(abs_spearman)), \
abs_pearson.index(max(abs_pearson)), \
abs_kendall.index(max(abs_kendall)), \
abs_eucDist.index(min(abs_eucDist)), \
scalarTestLoss.index(min(scalarTestLoss))]
best_model_ind = max(set(bests), key=bests.count)
print(bests, best_model_ind)
return best_model_ind, auto_list[best_model_ind]
def settfreproduceability(seed=42):
"""
Function enables reproduceablity for your experiments so that you can compare easily
Parameters:
seed (int): seed value for global randomness
"""
logging.warning(
"*** Modules are set to be deterministic , randomness in your modules will be avoided , Current seed value is {} change seed value if you want to try a different seed of parameters***"
.format(seed))
#Pythonic determinism
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
#Pythonic determinism
tf.random.set_seed(seed)
os.environ['TF_DETERMINISTIC_OPS'] = '1'
os.environ['TF_CUDNN_DETERMINISTIC'] = '1'
# https://www.tensorflow.org/api_docs/python/tf/config/threading/set_inter_op_parallelism_threads
tf.config.threading.set_inter_op_parallelism_threads(1)
tf.config.threading.set_intra_op_parallelism_threads(1)
from tfdeterminism import patch
patch()
# -*- coding: utf-8 -*-
"""
@author: danfeng
"""
#import library
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
import scipy.io as scio
import scipy.io as sio
from tf_utils import random_mini_batches_single, convert_to_one_hot
from tensorflow.python.framework import ops
from tfdeterminism import patch
patch()
def create_placeholders(n_x, n_y):
isTraining = tf.placeholder_with_default(True, shape=())
x = tf.placeholder(tf.float32, [None, n_x], name = "x")
y = tf.placeholder(tf.float32, [None, n_y], name = "Y")
return x, y, isTraining
def initialize_parameters():
tf.set_random_seed(1)
x_w1 = tf.get_variable("x_w1", [1,1,200,128], initializer = tf.contrib.layers.xavier_initializer(seed = 1))
x_b1 = tf.get_variable("x_b1", [128], initializer = tf.zeros_initializer())
#!/usr/bin/env python3
import argparse
import docker
import os
import shutil
import sys
import ast
import socket
import numpy as np
from tfdeterminism import patch
patch(
) # Ensure tf GPU determinism: https://github.com/NVIDIA/framework-determinism
import data.data_preprocess as prp
from metrics.metric_utils import feature_prediction, one_step_ahead_prediction, reidentify_score
from computils.misc import fix_all_random_seeds, tf_fixed_seed_seesion, redact_exception
from computils.solutions import (
load_data,
load_generated_data,
validate_hider_output,
validate_seeker_output,
benchmark_hider,
)
from running import competition_config, MAX_SEQ_LEN, TRAIN_RATE, DATA_FILE_NAME, FORCE_REPROCESS, SEED, DEBUG_DATA
DEFAULT_IMAGE = competition_config.get(
"DEFAULT_IMAGE", "drshushen/hide-and-seek-codalab:latest")
HIDER_EVAL_TRAINING_VERBOSE = competition_config.get(
def train(workdir,
env_name,
num_timesteps,
nsteps=256,
nminibatches=4,
noptepochs=4,
learning_rate=2.5e-4,
ent_coef=0.01,
patch_tf_determinism=False,
global_seed=None,
checkpoint_path_for_debugging=None):
"""Runs PPO training.
Args:
workdir: where to store experiment results/logs
env_name: the name of the environment to run
num_timesteps: for how many timesteps to run training
nsteps: Number of consecutive environment steps to use during training.
nminibatches: Minibatch size.
noptepochs: Number of optimization epochs.
learning_rate: Initial learning rate.
ent_coef: Entropy coefficient.
"""
if patch_tf_determinism:
from tfdeterminism import patch
patch()
print('Applied tfdeterminism.patch')
if global_seed is not None:
import random
import numpy as np
random.seed(global_seed)
np.random.seed(global_seed)
#tf.random.set_seed(global_seed)
tf.set_random_seed(global_seed)
#tf.debugging.set_log_device_placement(True)
train_measurements = utils.create_measurement_series(
workdir, 'reward_train')
valid_measurements = utils.create_measurement_series(
workdir, 'reward_valid')
test_measurements = utils.create_measurement_series(workdir, 'reward_test')
def measurement_callback(unused_eplenmean, eprewmean, global_step_val):
if train_measurements:
train_measurements.create_measurement(objective_value=eprewmean,
step=global_step_val)
logger.logkv('eprewmean_train', eprewmean)
def eval_callback_on_valid(eprewmean, global_step_val):
if valid_measurements:
valid_measurements.create_measurement(objective_value=eprewmean,
step=global_step_val)
logger.logkv('eprewmean_valid', eprewmean)
def eval_callback_on_test(eprewmean, global_step_val):
if test_measurements:
test_measurements.create_measurement(objective_value=eprewmean,
step=global_step_val)
logger.logkv('eprewmean_test', eprewmean)
logger_dir = workdir
#logger.configure(logger_dir)
logger.configure(dir=logger_dir,
format_strs=['tensorboard', 'stdout', 'log', 'csv'])
logger.Logger.DEFAULT = logger.Logger.CURRENT
rlb_ot = get_rlb_args().outer_args['rlb_ot']
env, valid_env, test_env = get_environment(
env_name,
create_env_fn=(rlb_env_factory.create_environments_with_rlb
if rlb_ot else env_factory.create_environments))
is_ant = env_name.startswith('parkour:')
# Validation metric.
policy_evaluator_on_valid = eval_policy.PolicyEvaluator(
valid_env, metric_callback=eval_callback_on_valid, video_filename=None)
# Test metric (+ videos).
video_filename = os.path.join(FLAGS.workdir, 'video')
policy_evaluator_on_test = eval_policy.PolicyEvaluator(
test_env,
metric_callback=eval_callback_on_test,
video_filename=video_filename,
grayscale=(env_name.startswith('atari:')))
# Delay to make sure that all the DMLab environments acquire
# the GPU resources before TensorFlow acquire the rest of the memory.
# TODO(damienv): Possibly use allow_grow in a TensorFlow session
# so that there is no such problem anymore.
time.sleep(15)
cloud_sync_callback = lambda: None
def evaluate_valid_test(model_step_fn, global_step):
if not is_ant:
policy_evaluator_on_valid.evaluate(model_step_fn, global_step)
policy_evaluator_on_test.evaluate(model_step_fn, global_step)
sess_config = tf.ConfigProto()
sess_config.gpu_options.allow_growth = True
if patch_tf_determinism:
sess_config.intra_op_parallelism_threads = 1
sess_config.inter_op_parallelism_threads = 1
#with tf.Session():
with tf.Session(config=sess_config):
policy = {
'cnn': policies.CnnPolicy,
'lstm': policies.LstmPolicy,
'lnlstm': policies.LnLstmPolicy,
'mlp': policies.MlpPolicy
}[FLAGS.policy_architecture]
# Openai baselines never performs num_timesteps env steps because
# of the way it samples training data in batches. The number of timesteps
# is multiplied by 1.1 (hacky) to insure at least num_timesteps are
# performed.
ppo2.learn(policy,
env=env,
nsteps=nsteps,
nminibatches=nminibatches,
lam=0.95,
gamma=0.99,
noptepochs=noptepochs,
log_interval=1,
ent_coef=ent_coef,
lr=learning_rate if is_ant else lambda f: f * learning_rate,
cliprange=0.2 if is_ant else lambda f: f * 0.1,
total_timesteps=int(num_timesteps * 1.1),
train_callback=measurement_callback,
eval_callback=evaluate_valid_test,
cloud_sync_callback=cloud_sync_callback,
save_interval=200,
workdir=workdir,
use_curiosity=FLAGS.use_curiosity,
curiosity_strength=FLAGS.curiosity_strength,
forward_inverse_ratio=FLAGS.forward_inverse_ratio,
curiosity_loss_strength=FLAGS.curiosity_loss_strength,
random_state_predictor=FLAGS.random_state_predictor,
use_rlb=(not rlb_ot),
checkpoint_path_for_debugging=checkpoint_path_for_debugging)
cloud_sync_callback()
test_env.close()
valid_env.close()
utils.maybe_close_measurements(train_measurements)
utils.maybe_close_measurements(valid_measurements)
utils.maybe_close_measurements(test_measurements)
