tf.random - LostTech.TensorFlow Documentation

Tensor categorical(IGraphNodeBase logits, int num_samples, DType dtype, object seed, string name)

Draws samples from a categorical distribution.

Example:

Parameters

IGraphNodeBase logits: 2-D Tensor with shape `[batch_size, num_classes]`. Each slice `[i, :]` represents the unnormalized log-probabilities for all classes.
int num_samples: 0-D. Number of independent samples to draw for each row slice.
DType dtype: integer type to use for the output. Defaults to int64.
object seed: A Python integer. Used to create a random seed for the distribution. See `tf.compat.v1.set_random_seed` for behavior.
string name: Optional name for the operation.

Returns

Tensor: The drawn samples of shape `[batch_size, num_samples]`.

# samples has shape [1, 5], where each value is either 0 or 1 with equal
            # probability.
            samples = tf.random.categorical(tf.math.log([[0.5, 0.5]]), 5)

Tensor categorical(IEnumerable<object> logits, int num_samples, DType dtype, object seed, string name)

Draws samples from a categorical distribution.

Example:

Parameters

IEnumerable<object> logits: 2-D Tensor with shape `[batch_size, num_classes]`. Each slice `[i, :]` represents the unnormalized log-probabilities for all classes.
int num_samples: 0-D. Number of independent samples to draw for each row slice.
DType dtype: integer type to use for the output. Defaults to int64.
object seed: A Python integer. Used to create a random seed for the distribution. See `tf.compat.v1.set_random_seed` for behavior.
string name: Optional name for the operation.

Returns

Tensor: The drawn samples of shape `[batch_size, num_samples]`.

Show Example

# samples has shape [1, 5], where each value is either 0 or 1 with equal
            # probability.
            samples = tf.random.categorical(tf.math.log([[0.5, 0.5]]), 5)

object categorical_dyn(object logits, object num_samples, object dtype, object seed, object name)

Draws samples from a categorical distribution.

Example:

Parameters

object logits: 2-D Tensor with shape `[batch_size, num_classes]`. Each slice `[i, :]` represents the unnormalized log-probabilities for all classes.
object num_samples: 0-D. Number of independent samples to draw for each row slice.
object dtype: integer type to use for the output. Defaults to int64.
object seed: A Python integer. Used to create a random seed for the distribution. See `tf.compat.v1.set_random_seed` for behavior.
object name: Optional name for the operation.

Returns

object: The drawn samples of shape `[batch_size, num_samples]`.

Show Example

# samples has shape [1, 5], where each value is either 0 or 1 with equal
            # probability.
            samples = tf.random.categorical(tf.math.log([[0.5, 0.5]]), 5)

void set_seed(object seed)

object set_seed_dyn(object seed)

Tensor stateless_categorical(object logits, object num_samples, object seed, ImplicitContainer<T> dtype, string name)

Draws deterministic pseudorandom samples from a categorical distribution.

This is a stateless version of `tf.categorical`: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Example:

Parameters

object logits: 2-D Tensor with shape `[batch_size, num_classes]`. Each slice `[i, :]` represents the unnormalized log-probabilities for all classes.
object num_samples: 0-D. Number of independent samples to draw for each row slice.
object seed: A shape [2] integer Tensor of seeds to the random number generator.
ImplicitContainer<T> dtype: integer type to use for the output. Defaults to int64.
string name: Optional name for the operation.

Returns

Tensor: The drawn samples of shape `[batch_size, num_samples]`.

Show Example

# samples has shape [1, 5], where each value is either 0 or 1 with equal
            # probability.
            samples = tf.random.stateless_categorical(
                tf.math.log([[0.5, 0.5]]), 5, seed=[7, 17])

object stateless_categorical_dyn(object logits, object num_samples, object seed, ImplicitContainer<T> dtype, object name)

Draws deterministic pseudorandom samples from a categorical distribution.

This is a stateless version of `tf.categorical`: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Example:

Parameters

object logits: 2-D Tensor with shape `[batch_size, num_classes]`. Each slice `[i, :]` represents the unnormalized log-probabilities for all classes.
object num_samples: 0-D. Number of independent samples to draw for each row slice.
object seed: A shape [2] integer Tensor of seeds to the random number generator.
ImplicitContainer<T> dtype: integer type to use for the output. Defaults to int64.
object name: Optional name for the operation.

Returns

object: The drawn samples of shape `[batch_size, num_samples]`.

Show Example

# samples has shape [1, 5], where each value is either 0 or 1 with equal
            # probability.
            samples = tf.random.stateless_categorical(
                tf.math.log([[0.5, 0.5]]), 5, seed=[7, 17])

Tensor stateless_multinomial(IGraphNodeBase logits, int num_samples, IGraphNodeBase seed, PythonClassContainer output_dtype, string name)

Draws deterministic pseudorandom samples from a multinomial distribution. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.random.stateless_categorical instead.

This is a stateless version of tf.random.categorical: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Example:

Parameters

IGraphNodeBase logits: 2-D Tensor with shape `[batch_size, num_classes]`. Each slice `[i, :]` represents the unnormalized log-probabilities for all classes.
int num_samples: 0-D. Number of independent samples to draw for each row slice.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
PythonClassContainer output_dtype: integer type to use for the output. Defaults to int64.
string name: Optional name for the operation.

Returns

Tensor: The drawn samples of shape `[batch_size, num_samples]`.

Show Example

# samples has shape [1, 5], where each value is either 0 or 1 with equal
            # probability.
            samples = tf.random.stateless_categorical(
                tf.math.log([[0.5, 0.5]]), 5, seed=[7, 17])

Tensor stateless_multinomial(IGraphNodeBase logits, int num_samples, IGraphNodeBase seed, ImplicitContainer<T> output_dtype, string name)

Draws deterministic pseudorandom samples from a multinomial distribution. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.random.stateless_categorical instead.

This is a stateless version of tf.random.categorical: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Example:

Parameters

IGraphNodeBase logits: 2-D Tensor with shape `[batch_size, num_classes]`. Each slice `[i, :]` represents the unnormalized log-probabilities for all classes.
int num_samples: 0-D. Number of independent samples to draw for each row slice.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
ImplicitContainer<T> output_dtype: integer type to use for the output. Defaults to int64.
string name: Optional name for the operation.

Returns

Tensor: The drawn samples of shape `[batch_size, num_samples]`.

Show Example

# samples has shape [1, 5], where each value is either 0 or 1 with equal
            # probability.
            samples = tf.random.stateless_categorical(
                tf.math.log([[0.5, 0.5]]), 5, seed=[7, 17])

Tensor stateless_multinomial(IEnumerable<object> logits, int num_samples, IGraphNodeBase seed, ImplicitContainer<T> output_dtype, string name)

Draws deterministic pseudorandom samples from a multinomial distribution. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.random.stateless_categorical instead.

This is a stateless version of tf.random.categorical: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Example:

Parameters

IEnumerable<object> logits: 2-D Tensor with shape `[batch_size, num_classes]`. Each slice `[i, :]` represents the unnormalized log-probabilities for all classes.
int num_samples: 0-D. Number of independent samples to draw for each row slice.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
ImplicitContainer<T> output_dtype: integer type to use for the output. Defaults to int64.
string name: Optional name for the operation.

Returns

Tensor: The drawn samples of shape `[batch_size, num_samples]`.

Show Example

# samples has shape [1, 5], where each value is either 0 or 1 with equal
            # probability.
            samples = tf.random.stateless_categorical(
                tf.math.log([[0.5, 0.5]]), 5, seed=[7, 17])

Tensor stateless_multinomial(IEnumerable<object> logits, int num_samples, IGraphNodeBase seed, PythonClassContainer output_dtype, string name)

Draws deterministic pseudorandom samples from a multinomial distribution. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.random.stateless_categorical instead.

This is a stateless version of tf.random.categorical: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Example:

Parameters

IEnumerable<object> logits: 2-D Tensor with shape `[batch_size, num_classes]`. Each slice `[i, :]` represents the unnormalized log-probabilities for all classes.
int num_samples: 0-D. Number of independent samples to draw for each row slice.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
PythonClassContainer output_dtype: integer type to use for the output. Defaults to int64.
string name: Optional name for the operation.

Returns

Tensor: The drawn samples of shape `[batch_size, num_samples]`.

Show Example

# samples has shape [1, 5], where each value is either 0 or 1 with equal
            # probability.
            samples = tf.random.stateless_categorical(
                tf.math.log([[0.5, 0.5]]), 5, seed=[7, 17])

Tensor stateless_normal(IEnumerable<int> shape, IGraphNodeBase seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(IEnumerable<int> shape, IGraphNodeBase seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(IEnumerable<int> shape, IGraphNodeBase seed, int mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(IEnumerable<int> shape, IGraphNodeBase seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(ValueTuple<int, object> shape, IEnumerable<object> seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(ValueTuple<int, object> shape, IEnumerable<object> seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(ValueTuple<int, object> shape, IEnumerable<object> seed, int mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(ValueTuple<int, object> shape, IEnumerable<object> seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(ValueTuple<int, object> shape, IGraphNodeBase seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(ValueTuple<int, object> shape, IGraphNodeBase seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(TensorShape shape, IEnumerable<object> seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

TensorShape shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(ValueTuple<int, object> shape, IGraphNodeBase seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(IEnumerable<int> shape, IEnumerable<object> seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(TensorShape shape, IEnumerable<object> seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

TensorShape shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(TensorShape shape, IEnumerable<object> seed, int mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

TensorShape shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(TensorShape shape, IEnumerable<object> seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

TensorShape shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(TensorShape shape, IGraphNodeBase seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

TensorShape shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(TensorShape shape, IGraphNodeBase seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

TensorShape shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(TensorShape shape, IGraphNodeBase seed, int mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

TensorShape shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(TensorShape shape, IGraphNodeBase seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

TensorShape shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(ValueTuple<int, object> shape, IGraphNodeBase seed, int mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(IEnumerable<int> shape, IEnumerable<object> seed, int mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(IEnumerable<int> shape, IEnumerable<object> seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

Tensor stateless_normal(IEnumerable<int> shape, IEnumerable<object> seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random normal values.

object stateless_normal_dyn(object shape, object seed, ImplicitContainer<T> mean, ImplicitContainer<T> stddev, ImplicitContainer<T> dtype, object name)

Outputs deterministic pseudorandom values from a normal distribution.

This is a stateless version of tf.random.normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

Parameters

object shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
object seed: A shape [2] integer Tensor of seeds to the random number generator.
ImplicitContainer<T> mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal distribution.
ImplicitContainer<T> stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution.
ImplicitContainer<T> dtype: The type of the output.
object name: A name for the operation (optional).

Returns

object: A tensor of the specified shape filled with random normal values.

Tensor stateless_truncated_normal(ValueTuple<int, object> shape, IEnumerable<object> seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(ValueTuple<int, object> shape, IGraphNodeBase seed, int mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(ValueTuple<int, object> shape, IGraphNodeBase seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(IEnumerable<int> shape, IGraphNodeBase seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(IEnumerable<int> shape, IGraphNodeBase seed, int mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(IEnumerable<int> shape, IGraphNodeBase seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(IEnumerable<int> shape, IGraphNodeBase seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(IEnumerable<int> shape, IEnumerable<object> seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(IEnumerable<int> shape, IEnumerable<object> seed, int mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(IEnumerable<int> shape, IEnumerable<object> seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(IEnumerable<int> shape, IEnumerable<object> seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(ValueTuple<int, object> shape, IEnumerable<object> seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(ValueTuple<int, object> shape, IEnumerable<object> seed, int mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
int mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(ValueTuple<int, object> shape, IEnumerable<object> seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<object> seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(ValueTuple<int, object> shape, IGraphNodeBase seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
int stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_truncated_normal(ValueTuple<int, object> shape, IGraphNodeBase seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
double stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random truncated normal values.

object stateless_truncated_normal_dyn(object shape, object seed, ImplicitContainer<T> mean, ImplicitContainer<T> stddev, ImplicitContainer<T> dtype, object name)

Outputs deterministic pseudorandom values, truncated normally distributed.

This is a stateless version of tf.random.truncated_normal: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

Parameters

object shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
object seed: A shape [2] integer Tensor of seeds to the random number generator.
ImplicitContainer<T> mean: A 0-D Tensor or Python value of type `dtype`. The mean of the truncated normal distribution.
ImplicitContainer<T> stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation of the normal distribution, before truncation.
ImplicitContainer<T> dtype: The type of the output.
object name: A name for the operation (optional).

Returns

object: A tensor of the specified shape filled with random truncated normal values.

Tensor stateless_uniform(IEnumerable<int> shape, IEnumerable<int> seed, int minval, Nullable<int> maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<int> seed: A shape [2] integer Tensor of seeds to the random number generator.
int minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
Nullable<int> maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(ValueTuple<int, object> shape, IGraphNodeBase seed, int minval, Nullable<int> maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
Nullable<int> maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(ValueTuple<int, object> shape, IGraphNodeBase seed, int minval, double maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
double maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(ValueTuple<int, object> shape, IGraphNodeBase seed, double minval, Nullable<int> maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
Nullable<int> maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(ValueTuple<int, object> shape, IGraphNodeBase seed, double minval, double maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
double maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(ValueTuple<int, object> shape, IEnumerable<int> seed, int minval, Nullable<int> maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<int> seed: A shape [2] integer Tensor of seeds to the random number generator.
int minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
Nullable<int> maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(IEnumerable<int> shape, IEnumerable<int> seed, int minval, double maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<int> seed: A shape [2] integer Tensor of seeds to the random number generator.
int minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
double maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(ValueTuple<int, object> shape, IEnumerable<int> seed, int minval, double maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<int> seed: A shape [2] integer Tensor of seeds to the random number generator.
int minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
double maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(ValueTuple<int, object> shape, IEnumerable<int> seed, double minval, double maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<int> seed: A shape [2] integer Tensor of seeds to the random number generator.
double minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
double maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(IEnumerable<int> shape, IGraphNodeBase seed, int minval, Nullable<int> maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
Nullable<int> maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(IEnumerable<int> shape, IGraphNodeBase seed, int minval, double maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
int minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
double maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(IEnumerable<int> shape, IGraphNodeBase seed, double minval, Nullable<int> maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
Nullable<int> maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(IEnumerable<int> shape, IGraphNodeBase seed, double minval, double maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IGraphNodeBase seed: A shape [2] integer Tensor of seeds to the random number generator.
double minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
double maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(IEnumerable<int> shape, IEnumerable<int> seed, double minval, double maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<int> seed: A shape [2] integer Tensor of seeds to the random number generator.
double minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
double maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(ValueTuple<int, object> shape, IEnumerable<int> seed, double minval, Nullable<int> maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

ValueTuple<int, object> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<int> seed: A shape [2] integer Tensor of seeds to the random number generator.
double minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
Nullable<int> maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

Tensor stateless_uniform(IEnumerable<int> shape, IEnumerable<int> seed, double minval, Nullable<int> maxval, ImplicitContainer<T> dtype, string name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

IEnumerable<int> shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
IEnumerable<int> seed: A shape [2] integer Tensor of seeds to the random number generator.
double minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
Nullable<int> maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
string name: A name for the operation (optional).

Returns

Tensor: A tensor of the specified shape filled with random uniform values.

object stateless_uniform_dyn(object shape, object seed, ImplicitContainer<T> minval, object maxval, ImplicitContainer<T> dtype, object name)

Outputs deterministic pseudorandom values from a uniform distribution.

This is a stateless version of tf.random.uniform: if run twice with the same seeds, it will produce the same pseudorandom numbers. The output is consistent across multiple runs on the same hardware (and between CPU and GPU), but may change between versions of TensorFlow or on non-CPU/GPU hardware.

The generated values follow a uniform distribution in the range `[minval, maxval)`. The lower bound `minval` is included in the range, while the upper bound `maxval` is excluded.

For floats, the default range is `[0, 1)`. For ints, at least `maxval` must be specified explicitly.

In the integer case, the random integers are slightly biased unless `maxval - minval` is an exact power of two. The bias is small for values of `maxval - minval` significantly smaller than the range of the output (either `2**32` or `2**64`).

Parameters

object shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
object seed: A shape [2] integer Tensor of seeds to the random number generator.
ImplicitContainer<T> minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the range of random values to generate. Defaults to 0.
object maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on the range of random values to generate. Defaults to 1 if `dtype` is floating point.
ImplicitContainer<T> dtype: The type of the output: `float16`, `float32`, `float64`, `int32`, or `int64`.
object name: A name for the operation (optional).

Returns

object: A tensor of the specified shape filled with random uniform values.

Methods

Properties

Public static methods

Tensor categorical(IGraphNodeBase logits, int num_samples, DType dtype, object seed, string name)

Parameters

Returns

Tensor categorical(IEnumerable<object> logits, int num_samples, DType dtype, object seed, string name)

Parameters

Returns

object categorical_dyn(object logits, object num_samples, object dtype, object seed, object name)

Parameters

Returns

void set_seed(object seed)

object set_seed_dyn(object seed)

Tensor stateless_categorical(object logits, object num_samples, object seed, ImplicitContainer<T> dtype, string name)

Parameters

Returns

object stateless_categorical_dyn(object logits, object num_samples, object seed, ImplicitContainer<T> dtype, object name)

Parameters

Returns

Tensor stateless_multinomial(IGraphNodeBase logits, int num_samples, IGraphNodeBase seed, PythonClassContainer output_dtype, string name)

Parameters

Returns

Tensor stateless_multinomial(IGraphNodeBase logits, int num_samples, IGraphNodeBase seed, ImplicitContainer<T> output_dtype, string name)

Parameters

Returns

Tensor stateless_multinomial(IEnumerable<object> logits, int num_samples, IGraphNodeBase seed, ImplicitContainer<T> output_dtype, string name)

Parameters

Returns

Tensor stateless_multinomial(IEnumerable<object> logits, int num_samples, IGraphNodeBase seed, PythonClassContainer output_dtype, string name)

Parameters

Returns

Tensor stateless_normal(IEnumerable<int> shape, IGraphNodeBase seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(IEnumerable<int> shape, IGraphNodeBase seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(IEnumerable<int> shape, IGraphNodeBase seed, int mean, double stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(IEnumerable<int> shape, IGraphNodeBase seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(ValueTuple<int, object> shape, IEnumerable<object> seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(ValueTuple<int, object> shape, IEnumerable<object> seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(ValueTuple<int, object> shape, IEnumerable<object> seed, int mean, double stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(ValueTuple<int, object> shape, IEnumerable<object> seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(ValueTuple<int, object> shape, IGraphNodeBase seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(ValueTuple<int, object> shape, IGraphNodeBase seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(TensorShape shape, IEnumerable<object> seed, double mean, double stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(ValueTuple<int, object> shape, IGraphNodeBase seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(IEnumerable<int> shape, IEnumerable<object> seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(TensorShape shape, IEnumerable<object> seed, double mean, int stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(TensorShape shape, IEnumerable<object> seed, int mean, double stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns

Tensor stateless_normal(TensorShape shape, IEnumerable<object> seed, int mean, int stddev, ImplicitContainer<T> dtype, string name)

Parameters

Returns