def tensorflow_random_state(seed: int) -> Generator[None, None, None]:
# Save values
origin_gpu_det = os.environ.get("TF_DETERMINISTIC_OPS", None)
orig_random_state = random.getstate()
orig_np_random_state = np.random.get_state()
if context.executing_eagerly():
tf_random_seed = context.global_seed()
else:
tf_random_seed = ops.get_default_graph().seed
determism_enabled = config.is_op_determinism_enabled()
config.enable_op_determinism()
# Set values
os.environ["TF_DETERMINISTIC_OPS"] = "1"
random.seed(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
yield
# Reset values
if origin_gpu_det is not None:
os.environ["TF_DETERMINISTIC_OPS"] = origin_gpu_det
else:
os.environ.pop("TF_DETERMINISTIC_OPS")
random.setstate(orig_random_state)
np.random.set_state(orig_np_random_state)
tf.random.set_seed(tf_random_seed)
if not determism_enabled:
config.disable_op_determinism()
def _testDilationGradDeterminismError(self, use_gpu):
if use_gpu and test.is_gpu_available(cuda_only=True):
try:
config.enable_op_determinism()
with self.assertRaisesRegexp(
errors_impl.UnimplementedError,
"Determinism is not yet supported "
"for Dilation2DBackpropInput."):
self._ConstructAndTestGradient(image_shape=[1, 3, 3, 1],
kernel_shape=[1, 1, 1],
strides=[1, 1],
rates=[1, 1],
padding="VALID",
use_gpu=use_gpu)
finally:
config.disable_op_determinism()
else:
try:
config.enable_op_determinism()
self._ConstructAndTestGradient(image_shape=[1, 3, 3, 1],
kernel_shape=[1, 1, 1],
strides=[1, 1],
rates=[1, 1],
padding="VALID",
use_gpu=use_gpu)
finally:
config.disable_op_determinism()
def testDeterminism(self):
# This does not test any ops are deterministic, because that is tested by
# many kernel tests.
try:
config.disable_op_determinism()
self.assertFalse(config.is_op_determinism_enabled())
config.enable_op_determinism()
self.assertTrue(config.is_op_determinism_enabled())
finally:
config.disable_op_determinism()
def testSuccessAfterError(self):
# Force an error on the TruncatedNormal kernel.
config.enable_op_determinism()
with self.assertRaisesRegex(
errors.InvalidArgumentError,
"When determinism is enabled, random ops must have a seed specified"
):
self.evaluate(
gen_random_ops.truncated_normal((1, ), dtypes.float32))
config.disable_op_determinism()
# Ensure the StdDev of the TruncatedNormal works as intended.
self.testStdDev()
def test_bincount_determinism_error(self):
num_samples = 10000
np.random.seed(42)
arr = np.random.randint(0, 1000, num_samples)
try:
config.enable_op_determinism()
with test_util.use_gpu():
if test_util.is_gpu_available(cuda_only=True):
with self.assertRaisesRegexp(
errors_impl.UnimplementedError,
"Determinism is not yet "
"supported for Bincount."):
self.evaluate(bincount_ops.bincount(arr, None))
finally:
config.disable_op_determinism()
def testDeterministicOpsErrors(self):
try:
config.enable_op_determinism()
random.set_global_generator(None)
with self.assertRaisesWithPredicateMatch(
RuntimeError,
'"get_global_generator" cannot be called if determinism is enabled'
):
random.get_global_generator()
random.set_global_generator(random.Generator.from_seed(50))
random.get_global_generator()
with self.assertRaisesWithPredicateMatch(
RuntimeError,
'"from_non_deterministic_state" cannot be called when determinism '
"is enabled."):
random.Generator.from_non_deterministic_state()
finally:
config.disable_op_determinism()
def test_no_determinism(self):
config.disable_op_determinism()
v = variables.Variable(0.)
def interleave_fn(x):
del x
v.assign(1.)
return dataset_ops.Dataset.range(2)
dataset = dataset_ops.Dataset.range(5)
dataset = dataset.apply(testing.assert_next(["ParallelInterleave"]))
dataset = dataset.interleave(interleave_fn,
cycle_length=5,
num_parallel_calls=3)
self.evaluate(variables.global_variables_initializer())
expected_output = [0] * 5 + [1] * 5
self.assertDatasetProduces(dataset,
expected_output=expected_output,
requires_initialization=True)
def tearDown(self):
super().tearDown()
config.disable_op_determinism()
