"""Python wrappers around TensorFlow ops. This file is MACHINE GENERATED! Do not edit. Original C++ source file: stateless_random_ops.cc """ import collections from tensorflow.python import pywrap_tfe as pywrap_tfe from tensorflow.python.eager import context as _context from tensorflow.python.eager import core as _core from tensorflow.python.eager import execute as _execute from tensorflow.python.framework import dtypes as _dtypes from tensorflow.python.framework import op_def_registry as _op_def_registry from tensorflow.python.framework import ops as _ops from tensorflow.python.framework import op_def_library as _op_def_library from tensorflow.python.util.deprecation import deprecated_endpoints from tensorflow.python.util import dispatch as _dispatch from tensorflow.python.util.tf_export import tf_export from typing import TypeVar def stateless_multinomial(logits, num_samples, seed, output_dtype=_dtypes.int64, name=None): r"""Draws samples from a multinomial distribution. Args: logits: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`. 2-D Tensor with shape `[batch_size, num_classes]`. Each slice `[i, :]` represents the unnormalized log probabilities for all classes. num_samples: A `Tensor` of type `int32`. 0-D. Number of independent samples to draw for each row slice. seed: A `Tensor`. Must be one of the following types: `int32`, `int64`. 2 seeds (shape [2]). output_dtype: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int64`. name: A name for the operation (optional). Returns: A `Tensor` of type `output_dtype`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatelessMultinomial", name, logits, num_samples, seed, "output_dtype", output_dtype) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateless_multinomial_eager_fallback( logits, num_samples, seed, output_dtype=output_dtype, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if output_dtype is None: output_dtype = _dtypes.int64 output_dtype = _execute.make_type(output_dtype, "output_dtype") _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatelessMultinomial", logits=logits, num_samples=num_samples, seed=seed, output_dtype=output_dtype, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("T", _op._get_attr_type("T"), "Tseed", _op._get_attr_type("Tseed"), "output_dtype", _op._get_attr_type("output_dtype")) _inputs_flat = _op.inputs _execute.record_gradient( "StatelessMultinomial", _inputs_flat, _attrs, _result) _result, = _result return _result StatelessMultinomial = tf_export("raw_ops.StatelessMultinomial")(_ops.to_raw_op(stateless_multinomial)) def stateless_multinomial_eager_fallback(logits, num_samples, seed, output_dtype, name, ctx): if output_dtype is None: output_dtype = _dtypes.int64 output_dtype = _execute.make_type(output_dtype, "output_dtype") _attr_T, (logits,) = _execute.args_to_matching_eager([logits], ctx, [_dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.uint8, _dtypes.int16, _dtypes.int8, _dtypes.int64, _dtypes.bfloat16, _dtypes.uint16, _dtypes.half, _dtypes.uint32, _dtypes.uint64, ]) _attr_Tseed, (seed,) = _execute.args_to_matching_eager([seed], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int64) num_samples = _ops.convert_to_tensor(num_samples, _dtypes.int32) _inputs_flat = [logits, num_samples, seed] _attrs = ("T", _attr_T, "Tseed", _attr_Tseed, "output_dtype", output_dtype) _result = _execute.execute(b"StatelessMultinomial", 1, inputs=_inputs_flat, attrs=_attrs, ctx=ctx, name=name) if _execute.must_record_gradient(): _execute.record_gradient( "StatelessMultinomial", _inputs_flat, _attrs, _result) _result, = _result return _result def stateless_parameterized_truncated_normal(shape, seed, means, stddevs, minvals, maxvals, name=None): r"""TODO: add doc. Args: shape: A `Tensor`. Must be one of the following types: `int32`, `int64`. The shape of the output tensor. seed: A `Tensor`. Must be one of the following types: `int32`, `int64`. 2 seeds (shape [2]). means: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`. The mean parameter of each batch. stddevs: A `Tensor`. Must have the same type as `means`. The standard deviation parameter of each batch. Must be greater than 0. minvals: A `Tensor`. Must have the same type as `means`. The minimum cutoff. May be -infinity. maxvals: A `Tensor`. Must have the same type as `means`. The maximum cutoff. May be +infinity, and must be more than the minval for each batch. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `means`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatelessParameterizedTruncatedNormal", name, shape, seed, means, stddevs, minvals, maxvals) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateless_parameterized_truncated_normal_eager_fallback( shape, seed, means, stddevs, minvals, maxvals, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatelessParameterizedTruncatedNormal", shape=shape, seed=seed, means=means, stddevs=stddevs, minvals=minvals, maxvals=maxvals, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("S", _op._get_attr_type("S"), "Tseed", _op._get_attr_type("Tseed"), "dtype", _op._get_attr_type("dtype")) _inputs_flat = _op.inputs _execute.record_gradient( "StatelessParameterizedTruncatedNormal", _inputs_flat, _attrs, _result) _result, = _result return _result StatelessParameterizedTruncatedNormal = tf_export("raw_ops.StatelessParameterizedTruncatedNormal")(_ops.to_raw_op(stateless_parameterized_truncated_normal)) def stateless_parameterized_truncated_normal_eager_fallback(shape, seed, means, stddevs, minvals, maxvals, name, ctx): _attr_S, (shape,) = _execute.args_to_matching_eager([shape], ctx, [_dtypes.int32, _dtypes.int64, ]) _attr_Tseed, (seed,) = _execute.args_to_matching_eager([seed], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int64) _attr_dtype, _inputs_dtype = _execute.args_to_matching_eager([means, stddevs, minvals, maxvals], ctx, [_dtypes.half, _dtypes.float32, _dtypes.float64, ]) (means, stddevs, minvals, maxvals) = _inputs_dtype _inputs_flat = [shape, seed, means, stddevs, minvals, maxvals] _attrs = ("S", _attr_S, "Tseed", _attr_Tseed, "dtype", _attr_dtype) _result = _execute.execute(b"StatelessParameterizedTruncatedNormal", 1, inputs=_inputs_flat, attrs=_attrs, ctx=ctx, name=name) if _execute.must_record_gradient(): _execute.record_gradient( "StatelessParameterizedTruncatedNormal", _inputs_flat, _attrs, _result) _result, = _result return _result def stateless_random_binomial(shape, seed, counts, probs, dtype=_dtypes.int64, name=None): r"""Outputs deterministic pseudorandom random numbers from a binomial distribution. Outputs random values from a binomial distribution. The outputs are a deterministic function of `shape`, `seed`, `counts`, and `probs`. Args: shape: A `Tensor`. Must be one of the following types: `int32`, `int64`. The shape of the output tensor. seed: A `Tensor`. Must be one of the following types: `int32`, `int64`. 2 seeds (shape [2]). counts: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`. The counts of the binomial distribution. Must be broadcastable with `probs`, and broadcastable with the rightmost dimensions of `shape`. probs: A `Tensor`. Must have the same type as `counts`. The probability of success for the binomial distribution. Must be broadcastable with `counts` and broadcastable with the rightmost dimensions of `shape`. dtype: An optional `tf.DType` from: `tf.half, tf.float32, tf.float64, tf.int32, tf.int64`. Defaults to `tf.int64`. The type of the output. name: A name for the operation (optional). Returns: A `Tensor` of type `dtype`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatelessRandomBinomial", name, shape, seed, counts, probs, "dtype", dtype) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateless_random_binomial_eager_fallback( shape, seed, counts, probs, dtype=dtype, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if dtype is None: dtype = _dtypes.int64 dtype = _execute.make_type(dtype, "dtype") _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatelessRandomBinomial", shape=shape, seed=seed, counts=counts, probs=probs, dtype=dtype, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("S", _op._get_attr_type("S"), "Tseed", _op._get_attr_type("Tseed"), "T", _op._get_attr_type("T"), "dtype", _op._get_attr_type("dtype")) _inputs_flat = _op.inputs _execute.record_gradient( "StatelessRandomBinomial", _inputs_flat, _attrs, _result) _result, = _result return _result StatelessRandomBinomial = tf_export("raw_ops.StatelessRandomBinomial")(_ops.to_raw_op(stateless_random_binomial)) def stateless_random_binomial_eager_fallback(shape, seed, counts, probs, dtype, name, ctx): if dtype is None: dtype = _dtypes.int64 dtype = _execute.make_type(dtype, "dtype") _attr_S, (shape,) = _execute.args_to_matching_eager([shape], ctx, [_dtypes.int32, _dtypes.int64, ]) _attr_Tseed, (seed,) = _execute.args_to_matching_eager([seed], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int64) _attr_T, _inputs_T = _execute.args_to_matching_eager([counts, probs], ctx, [_dtypes.half, _dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.int64, ], _dtypes.float64) (counts, probs) = _inputs_T _inputs_flat = [shape, seed, counts, probs] _attrs = ("S", _attr_S, "Tseed", _attr_Tseed, "T", _attr_T, "dtype", dtype) _result = _execute.execute(b"StatelessRandomBinomial", 1, inputs=_inputs_flat, attrs=_attrs, ctx=ctx, name=name) if _execute.must_record_gradient(): _execute.record_gradient( "StatelessRandomBinomial", _inputs_flat, _attrs, _result) _result, = _result return _result def stateless_random_gamma_v2(shape, seed, alpha, name=None): r"""Outputs deterministic pseudorandom random numbers from a gamma distribution. Outputs random values from a gamma distribution. The outputs are a deterministic function of `shape`, `seed`, and `alpha`. Args: shape: A `Tensor`. Must be one of the following types: `int32`, `int64`. The shape of the output tensor. seed: A `Tensor`. Must be one of the following types: `int32`, `int64`. 2 seeds (shape [2]). alpha: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`. The concentration of the gamma distribution. Shape must match the rightmost dimensions of `shape`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `alpha`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatelessRandomGammaV2", name, shape, seed, alpha) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateless_random_gamma_v2_eager_fallback( shape, seed, alpha, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatelessRandomGammaV2", shape=shape, seed=seed, alpha=alpha, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("dtype", _op._get_attr_type("dtype"), "T", _op._get_attr_type("T"), "Tseed", _op._get_attr_type("Tseed")) _inputs_flat = _op.inputs _execute.record_gradient( "StatelessRandomGammaV2", _inputs_flat, _attrs, _result) _result, = _result return _result StatelessRandomGammaV2 = tf_export("raw_ops.StatelessRandomGammaV2")(_ops.to_raw_op(stateless_random_gamma_v2)) def stateless_random_gamma_v2_eager_fallback(shape, seed, alpha, name, ctx): _attr_dtype, (alpha,) = _execute.args_to_matching_eager([alpha], ctx, [_dtypes.half, _dtypes.float32, _dtypes.float64, ]) _attr_T, (shape,) = _execute.args_to_matching_eager([shape], ctx, [_dtypes.int32, _dtypes.int64, ]) _attr_Tseed, (seed,) = _execute.args_to_matching_eager([seed], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int64) _inputs_flat = [shape, seed, alpha] _attrs = ("dtype", _attr_dtype, "T", _attr_T, "Tseed", _attr_Tseed) _result = _execute.execute(b"StatelessRandomGammaV2", 1, inputs=_inputs_flat, attrs=_attrs, ctx=ctx, name=name) if _execute.must_record_gradient(): _execute.record_gradient( "StatelessRandomGammaV2", _inputs_flat, _attrs, _result) _result, = _result return _result def stateless_random_normal(shape, seed, dtype=_dtypes.float32, name=None): r"""Outputs deterministic pseudorandom values from a normal distribution. The generated values will have mean 0 and standard deviation 1. The outputs are a deterministic function of `shape` and `seed`. Args: shape: A `Tensor`. Must be one of the following types: `int32`, `int64`. The shape of the output tensor. seed: A `Tensor`. Must be one of the following types: `int32`, `int64`. 2 seeds (shape [2]). dtype: An optional `tf.DType` from: `tf.half, tf.bfloat16, tf.float32, tf.float64`. Defaults to `tf.float32`. The type of the output. name: A name for the operation (optional). Returns: A `Tensor` of type `dtype`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatelessRandomNormal", name, shape, seed, "dtype", dtype) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateless_random_normal_eager_fallback( shape, seed, dtype=dtype, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if dtype is None: dtype = _dtypes.float32 dtype = _execute.make_type(dtype, "dtype") _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatelessRandomNormal", shape=shape, seed=seed, dtype=dtype, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("dtype", _op._get_attr_type("dtype"), "T", _op._get_attr_type("T"), "Tseed", _op._get_attr_type("Tseed")) _inputs_flat = _op.inputs _execute.record_gradient( "StatelessRandomNormal", _inputs_flat, _attrs, _result) _result, = _result return _result StatelessRandomNormal = tf_export("raw_ops.StatelessRandomNormal")(_ops.to_raw_op(stateless_random_normal)) def stateless_random_normal_eager_fallback(shape, seed, dtype, name, ctx): if dtype is None: dtype = _dtypes.float32 dtype = _execute.make_type(dtype, "dtype") _attr_T, (shape,) = _execute.args_to_matching_eager([shape], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int32) _attr_Tseed, (seed,) = _execute.args_to_matching_eager([seed], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int64) _inputs_flat = [shape, seed] _attrs = ("dtype", dtype, "T", _attr_T, "Tseed", _attr_Tseed) _result = _execute.execute(b"StatelessRandomNormal", 1, inputs=_inputs_flat, attrs=_attrs, ctx=ctx, name=name) if _execute.must_record_gradient(): _execute.record_gradient( "StatelessRandomNormal", _inputs_flat, _attrs, _result) _result, = _result return _result def stateless_random_poisson(shape, seed, lam, dtype, name=None): r"""Outputs deterministic pseudorandom random numbers from a Poisson distribution. Outputs random values from a Poisson distribution. The outputs are a deterministic function of `shape`, `seed`, and `lam`. Args: shape: A `Tensor`. Must be one of the following types: `int32`, `int64`. The shape of the output tensor. seed: A `Tensor`. Must be one of the following types: `int32`, `int64`. 2 seeds (shape [2]). lam: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`. The rate of the Poisson distribution. Shape must match the rightmost dimensions of `shape`. dtype: A `tf.DType` from: `tf.half, tf.float32, tf.float64, tf.int32, tf.int64`. The type of the output. name: A name for the operation (optional). Returns: A `Tensor` of type `dtype`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatelessRandomPoisson", name, shape, seed, lam, "dtype", dtype) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateless_random_poisson_eager_fallback( shape, seed, lam, dtype=dtype, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. dtype = _execute.make_type(dtype, "dtype") _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatelessRandomPoisson", shape=shape, seed=seed, lam=lam, dtype=dtype, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("Rtype", _op._get_attr_type("Rtype"), "dtype", _op._get_attr_type("dtype"), "T", _op._get_attr_type("T"), "Tseed", _op._get_attr_type("Tseed")) _inputs_flat = _op.inputs _execute.record_gradient( "StatelessRandomPoisson", _inputs_flat, _attrs, _result) _result, = _result return _result StatelessRandomPoisson = tf_export("raw_ops.StatelessRandomPoisson")(_ops.to_raw_op(stateless_random_poisson)) def stateless_random_poisson_eager_fallback(shape, seed, lam, dtype, name, ctx): dtype = _execute.make_type(dtype, "dtype") _attr_Rtype, (lam,) = _execute.args_to_matching_eager([lam], ctx, [_dtypes.half, _dtypes.float32, _dtypes.float64, _dtypes.int32, _dtypes.int64, ]) _attr_T, (shape,) = _execute.args_to_matching_eager([shape], ctx, [_dtypes.int32, _dtypes.int64, ]) _attr_Tseed, (seed,) = _execute.args_to_matching_eager([seed], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int64) _inputs_flat = [shape, seed, lam] _attrs = ("Rtype", _attr_Rtype, "dtype", dtype, "T", _attr_T, "Tseed", _attr_Tseed) _result = _execute.execute(b"StatelessRandomPoisson", 1, inputs=_inputs_flat, attrs=_attrs, ctx=ctx, name=name) if _execute.must_record_gradient(): _execute.record_gradient( "StatelessRandomPoisson", _inputs_flat, _attrs, _result) _result, = _result return _result def stateless_random_uniform(shape, seed, dtype=_dtypes.float32, name=None): r"""Outputs deterministic pseudorandom random values from a uniform distribution. The generated values follow a uniform distribution in the range `[0, 1)`. The lower bound 0 is included in the range, while the upper bound 1 is excluded. The outputs are a deterministic function of `shape` and `seed`. Args: shape: A `Tensor`. Must be one of the following types: `int32`, `int64`. The shape of the output tensor. seed: A `Tensor`. Must be one of the following types: `int32`, `int64`. 2 seeds (shape [2]). dtype: An optional `tf.DType` from: `tf.half, tf.bfloat16, tf.float32, tf.float64`. Defaults to `tf.float32`. The type of the output. name: A name for the operation (optional). Returns: A `Tensor` of type `dtype`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatelessRandomUniform", name, shape, seed, "dtype", dtype) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateless_random_uniform_eager_fallback( shape, seed, dtype=dtype, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if dtype is None: dtype = _dtypes.float32 dtype = _execute.make_type(dtype, "dtype") _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatelessRandomUniform", shape=shape, seed=seed, dtype=dtype, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("dtype", _op._get_attr_type("dtype"), "T", _op._get_attr_type("T"), "Tseed", _op._get_attr_type("Tseed")) _inputs_flat = _op.inputs _execute.record_gradient( "StatelessRandomUniform", _inputs_flat, _attrs, _result) _result, = _result return _result StatelessRandomUniform = tf_export("raw_ops.StatelessRandomUniform")(_ops.to_raw_op(stateless_random_uniform)) def stateless_random_uniform_eager_fallback(shape, seed, dtype, name, ctx): if dtype is None: dtype = _dtypes.float32 dtype = _execute.make_type(dtype, "dtype") _attr_T, (shape,) = _execute.args_to_matching_eager([shape], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int32) _attr_Tseed, (seed,) = _execute.args_to_matching_eager([seed], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int64) _inputs_flat = [shape, seed] _attrs = ("dtype", dtype, "T", _attr_T, "Tseed", _attr_Tseed) _result = _execute.execute(b"StatelessRandomUniform", 1, inputs=_inputs_flat, attrs=_attrs, ctx=ctx, name=name) if _execute.must_record_gradient(): _execute.record_gradient( "StatelessRandomUniform", _inputs_flat, _attrs, _result) _result, = _result return _result def stateless_random_uniform_full_int(shape, seed, dtype=_dtypes.uint64, name=None): r"""Outputs deterministic pseudorandom random integers from a uniform distribution. The generated values are uniform integers covering the whole range of `dtype`. The outputs are a deterministic function of `shape` and `seed`. Args: shape: A `Tensor`. Must be one of the following types: `int32`, `int64`. The shape of the output tensor. seed: A `Tensor`. Must be one of the following types: `int32`, `int64`, `uint32`, `uint64`. 2 seeds (shape [2]). dtype: An optional `tf.DType` from: `tf.int32, tf.int64, tf.uint32, tf.uint64`. Defaults to `tf.uint64`. The type of the output. name: A name for the operation (optional). Returns: A `Tensor` of type `dtype`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatelessRandomUniformFullInt", name, shape, seed, "dtype", dtype) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateless_random_uniform_full_int_eager_fallback( shape, seed, dtype=dtype, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if dtype is None: dtype = _dtypes.uint64 dtype = _execute.make_type(dtype, "dtype") _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatelessRandomUniformFullInt", shape=shape, seed=seed, dtype=dtype, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("dtype", _op._get_attr_type("dtype"), "T", _op._get_attr_type("T"), "Tseed", _op._get_attr_type("Tseed")) _inputs_flat = _op.inputs _execute.record_gradient( "StatelessRandomUniformFullInt", _inputs_flat, _attrs, _result) _result, = _result return _result StatelessRandomUniformFullInt = tf_export("raw_ops.StatelessRandomUniformFullInt")(_ops.to_raw_op(stateless_random_uniform_full_int)) def stateless_random_uniform_full_int_eager_fallback(shape, seed, dtype, name, ctx): if dtype is None: dtype = _dtypes.uint64 dtype = _execute.make_type(dtype, "dtype") _attr_T, (shape,) = _execute.args_to_matching_eager([shape], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int32) _attr_Tseed, (seed,) = _execute.args_to_matching_eager([seed], ctx, [_dtypes.int32, _dtypes.int64, _dtypes.uint32, _dtypes.uint64, ], _dtypes.int64) _inputs_flat = [shape, seed] _attrs = ("dtype", dtype, "T", _attr_T, "Tseed", _attr_Tseed) _result = _execute.execute(b"StatelessRandomUniformFullInt", 1, inputs=_inputs_flat, attrs=_attrs, ctx=ctx, name=name) if _execute.must_record_gradient(): _execute.record_gradient( "StatelessRandomUniformFullInt", _inputs_flat, _attrs, _result) _result, = _result return _result def stateless_random_uniform_int(shape, seed, minval, maxval, name=None): r"""Outputs deterministic pseudorandom random integers from a uniform distribution. The generated values follow a uniform distribution in the range `[minval, maxval)`. The outputs are a deterministic function of `shape`, `seed`, `minval`, and `maxval`. Args: shape: A `Tensor`. Must be one of the following types: `int32`, `int64`. The shape of the output tensor. seed: A `Tensor`. Must be one of the following types: `int32`, `int64`. 2 seeds (shape [2]). minval: A `Tensor`. Must be one of the following types: `int32`, `int64`. Minimum value (inclusive, scalar). maxval: A `Tensor`. Must have the same type as `minval`. Maximum value (exclusive, scalar). name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `minval`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatelessRandomUniformInt", name, shape, seed, minval, maxval) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateless_random_uniform_int_eager_fallback( shape, seed, minval, maxval, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatelessRandomUniformInt", shape=shape, seed=seed, minval=minval, maxval=maxval, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("dtype", _op._get_attr_type("dtype"), "T", _op._get_attr_type("T"), "Tseed", _op._get_attr_type("Tseed")) _inputs_flat = _op.inputs _execute.record_gradient( "StatelessRandomUniformInt", _inputs_flat, _attrs, _result) _result, = _result return _result StatelessRandomUniformInt = tf_export("raw_ops.StatelessRandomUniformInt")(_ops.to_raw_op(stateless_random_uniform_int)) def stateless_random_uniform_int_eager_fallback(shape, seed, minval, maxval, name, ctx): _attr_dtype, _inputs_dtype = _execute.args_to_matching_eager([minval, maxval], ctx, [_dtypes.int32, _dtypes.int64, ]) (minval, maxval) = _inputs_dtype _attr_T, (shape,) = _execute.args_to_matching_eager([shape], ctx, [_dtypes.int32, _dtypes.int64, ]) _attr_Tseed, (seed,) = _execute.args_to_matching_eager([seed], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int64) _inputs_flat = [shape, seed, minval, maxval] _attrs = ("dtype", _attr_dtype, "T", _attr_T, "Tseed", _attr_Tseed) _result = _execute.execute(b"StatelessRandomUniformInt", 1, inputs=_inputs_flat, attrs=_attrs, ctx=ctx, name=name) if _execute.must_record_gradient(): _execute.record_gradient( "StatelessRandomUniformInt", _inputs_flat, _attrs, _result) _result, = _result return _result def stateless_truncated_normal(shape, seed, dtype=_dtypes.float32, name=None): r"""Outputs deterministic pseudorandom values from a truncated normal distribution. The generated values follow a normal distribution with mean 0 and standard deviation 1, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked. The outputs are a deterministic function of `shape` and `seed`. Args: shape: A `Tensor`. Must be one of the following types: `int32`, `int64`. The shape of the output tensor. seed: A `Tensor`. Must be one of the following types: `int32`, `int64`. 2 seeds (shape [2]). dtype: An optional `tf.DType` from: `tf.half, tf.bfloat16, tf.float32, tf.float64`. Defaults to `tf.float32`. The type of the output. name: A name for the operation (optional). Returns: A `Tensor` of type `dtype`. """ _ctx = _context._context or _context.context() tld = _ctx._thread_local_data if tld.is_eager: try: _result = pywrap_tfe.TFE_Py_FastPathExecute( _ctx, "StatelessTruncatedNormal", name, shape, seed, "dtype", dtype) return _result except _core._NotOkStatusException as e: _ops.raise_from_not_ok_status(e, name) except _core._FallbackException: pass try: return stateless_truncated_normal_eager_fallback( shape, seed, dtype=dtype, name=name, ctx=_ctx) except _core._SymbolicException: pass # Add nodes to the TensorFlow graph. # Add nodes to the TensorFlow graph. if dtype is None: dtype = _dtypes.float32 dtype = _execute.make_type(dtype, "dtype") _, _, _op, _outputs = _op_def_library._apply_op_helper( "StatelessTruncatedNormal", shape=shape, seed=seed, dtype=dtype, name=name) _result = _outputs[:] if _execute.must_record_gradient(): _attrs = ("dtype", _op._get_attr_type("dtype"), "T", _op._get_attr_type("T"), "Tseed", _op._get_attr_type("Tseed")) _inputs_flat = _op.inputs _execute.record_gradient( "StatelessTruncatedNormal", _inputs_flat, _attrs, _result) _result, = _result return _result StatelessTruncatedNormal = tf_export("raw_ops.StatelessTruncatedNormal")(_ops.to_raw_op(stateless_truncated_normal)) def stateless_truncated_normal_eager_fallback(shape, seed, dtype, name, ctx): if dtype is None: dtype = _dtypes.float32 dtype = _execute.make_type(dtype, "dtype") _attr_T, (shape,) = _execute.args_to_matching_eager([shape], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int32) _attr_Tseed, (seed,) = _execute.args_to_matching_eager([seed], ctx, [_dtypes.int32, _dtypes.int64, ], _dtypes.int64) _inputs_flat = [shape, seed] _attrs = ("dtype", dtype, "T", _attr_T, "Tseed", _attr_Tseed) _result = _execute.execute(b"StatelessTruncatedNormal", 1, inputs=_inputs_flat, attrs=_attrs, ctx=ctx, name=name) if _execute.must_record_gradient(): _execute.record_gradient( "StatelessTruncatedNormal", _inputs_flat, _attrs, _result) _result, = _result return _result