LostTech.TensorFlow : API Documentation

Type tf.test

Namespace tensorflow

Public static methods

object benchmark_config()

Returns a tf.compat.v1.ConfigProto for disabling the dependency optimizer.
Returns
object
A TensorFlow ConfigProto object.

object benchmark_config_dyn()

Returns a tf.compat.v1.ConfigProto for disabling the dependency optimizer.
Returns
object
A TensorFlow ConfigProto object.

object compute_gradient(IGraphNodeBase x, TensorShape x_shape, object y, TensorShape y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
IGraphNodeBase x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
TensorShape y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(ndarray x, IEnumerable<object> x_shape, object y, TensorShape y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
ndarray x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
TensorShape y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(ndarray x, TensorShape x_shape, object y, IEnumerable<int> y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
ndarray x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
IEnumerable<int> y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(ndarray x, TensorShape x_shape, object y, TensorShape y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
ndarray x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
TensorShape y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(IDictionary<object, object> x, IEnumerable<object> x_shape, object y, IEnumerable<int> y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
IDictionary<object, object> x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
IEnumerable<int> y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(IDictionary<object, object> x, IEnumerable<object> x_shape, object y, TensorShape y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
IDictionary<object, object> x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
TensorShape y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(IDictionary<object, object> x, TensorShape x_shape, object y, IEnumerable<int> y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
IDictionary<object, object> x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
IEnumerable<int> y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(IDictionary<object, object> x, TensorShape x_shape, object y, TensorShape y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
IDictionary<object, object> x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
TensorShape y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(IEnumerable<object> x, IEnumerable<object> x_shape, object y, IEnumerable<int> y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
IEnumerable<object> x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
IEnumerable<int> y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(IEnumerable<object> x, IEnumerable<object> x_shape, object y, TensorShape y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
IEnumerable<object> x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
TensorShape y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(IEnumerable<object> x, TensorShape x_shape, object y, IEnumerable<int> y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
IEnumerable<object> x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
IEnumerable<int> y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(IEnumerable<object> x, TensorShape x_shape, object y, TensorShape y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
IEnumerable<object> x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
TensorShape y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(ValueTuple<double, object> x, IEnumerable<object> x_shape, object y, IEnumerable<int> y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
ValueTuple<double, object> x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
IEnumerable<int> y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(ValueTuple<double, object> x, IEnumerable<object> x_shape, object y, TensorShape y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
ValueTuple<double, object> x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
TensorShape y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(ValueTuple<double, object> x, TensorShape x_shape, object y, IEnumerable<int> y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
ValueTuple<double, object> x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
IEnumerable<int> y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(ValueTuple<double, object> x, TensorShape x_shape, object y, TensorShape y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
ValueTuple<double, object> x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
TensorShape y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(RaggedTensor x, IEnumerable<object> x_shape, object y, IEnumerable<int> y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
RaggedTensor x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
IEnumerable<int> y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(RaggedTensor x, IEnumerable<object> x_shape, object y, TensorShape y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
RaggedTensor x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
TensorShape y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(RaggedTensor x, TensorShape x_shape, object y, IEnumerable<int> y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
RaggedTensor x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
IEnumerable<int> y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(RaggedTensor x, TensorShape x_shape, object y, TensorShape y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
RaggedTensor x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
TensorShape y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(IGraphNodeBase x, IEnumerable<object> x_shape, object y, IEnumerable<int> y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
IGraphNodeBase x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
IEnumerable<int> y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(IGraphNodeBase x, IEnumerable<object> x_shape, object y, TensorShape y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
IGraphNodeBase x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
TensorShape y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(ndarray x, IEnumerable<object> x_shape, object y, IEnumerable<int> y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
ndarray x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
IEnumerable<int> y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient(IGraphNodeBase x, TensorShape x_shape, object y, IEnumerable<int> y_shape, object x_init_value, ImplicitContainer<T> delta, Nullable<ValueTuple<IEnumerable<object>, object>> init_targets, IDictionary<object, object> extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
IGraphNodeBase x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
IEnumerable<int> y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
Nullable<ValueTuple<IEnumerable<object>, object>> init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

object compute_gradient_dyn(object x, object x_shape, object y, object y_shape, object x_init_value, ImplicitContainer<T> delta, object init_targets, object extra_feed_dict)

Computes and returns the theoretical and numerical Jacobian. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

If `x` or `y` is complex, the Jacobian will still be real but the corresponding Jacobian dimension(s) will be twice as large. This is required even if both input and output is complex since TensorFlow graphs are not necessarily holomorphic, and may have gradients not expressible as complex numbers. For example, if `x` is complex with shape `[m]` and `y` is complex with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with

J[:m, :n] = d(Re y)/d(Re x) J[:m, n:] = d(Im y)/d(Re x) J[m:, :n] = d(Re y)/d(Im x) J[m:, n:] = d(Im y)/d(Im x)
Parameters
object x
a tensor or list of tensors
object x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
object extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
Two 2-d numpy arrays representing the theoretical and numerical Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns where "x_size" is the number of elements in x and "y_size" is the number of elements in y. If x is a list, returns a list of two numpy arrays.

int compute_gradient_error(RaggedTensor x, ValueTuple<int, object, int> x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
RaggedTensor x
a tensor or list of tensors
ValueTuple<int, object, int> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(ValueTuple<double, object> x, ValueTuple<int, object, int> x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
ValueTuple<double, object> x
a tensor or list of tensors
ValueTuple<int, object, int> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(ValueTuple<double, object> x, TensorShape x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
ValueTuple<double, object> x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(RaggedTensor x, IEnumerable<object> x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
RaggedTensor x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(IEnumerable<IGraphNodeBase> x, ValueTuple<int, object, int> x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
IEnumerable<IGraphNodeBase> x
a tensor or list of tensors
ValueTuple<int, object, int> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(RaggedTensor x, TensorShape x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
RaggedTensor x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(IGraphNodeBase x, IEnumerable<object> x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
IGraphNodeBase x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(IGraphNodeBase x, ValueTuple<int, object, int> x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
IGraphNodeBase x
a tensor or list of tensors
ValueTuple<int, object, int> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(IGraphNodeBase x, TensorShape x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
IGraphNodeBase x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(ValueTuple<double, object> x, IEnumerable<object> x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
ValueTuple<double, object> x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(IEnumerable<IGraphNodeBase> x, TensorShape x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
IEnumerable<IGraphNodeBase> x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(IDictionary<object, object> x, TensorShape x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
IDictionary<object, object> x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(IDictionary<object, object> x, ValueTuple<int, object, int> x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
IDictionary<object, object> x
a tensor or list of tensors
ValueTuple<int, object, int> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(IDictionary<object, object> x, IEnumerable<object> x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
IDictionary<object, object> x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(ndarray x, TensorShape x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
ndarray x
a tensor or list of tensors
TensorShape x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(ndarray x, ValueTuple<int, object, int> x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
ndarray x
a tensor or list of tensors
ValueTuple<int, object, int> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(ndarray x, IEnumerable<object> x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
ndarray x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

int compute_gradient_error(IEnumerable<IGraphNodeBase> x, IEnumerable<object> x_shape, object y, object y_shape, object x_init_value, double delta, object init_targets, IDictionary<object, object> extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
IEnumerable<IGraphNodeBase> x
a tensor or list of tensors
IEnumerable<object> x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
double delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
IDictionary<object, object> extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
int
The maximum error in between the two Jacobians.

object compute_gradient_error_dyn(object x, object x_shape, object y, object y_shape, object x_init_value, ImplicitContainer<T> delta, object init_targets, object extra_feed_dict)

Computes the gradient error. (deprecated)

Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Use tf.test.compute_gradient in 2.0, which has better support for functions. Note that the two versions have different usage, so code change is needed.

Computes the maximum error for dy/dx between the computed Jacobian and the numerically estimated Jacobian.

This function will modify the tensors passed in as it adds more operations and hence changing the consumers of the operations of the input tensors.

This function adds operations to the current session. To compute the error using a particular device, such as a GPU, use the standard methods for setting a device (e.g. using with sess.graph.device() or setting a device function in the session constructor).
Parameters
object x
a tensor or list of tensors
object x_shape
the dimensions of x as a tuple or an array of ints. If x is a list, then this is the list of shapes.
object y
a tensor
object y_shape
the dimensions of y as a tuple or an array of ints.
object x_init_value
(optional) a numpy array of the same shape as "x" representing the initial value of x. If x is a list, this should be a list of numpy arrays. If this is none, the function will pick a random tensor as the initial value.
ImplicitContainer<T> delta
(optional) the amount of perturbation.
object init_targets
list of targets to run to initialize model params.
object extra_feed_dict
dict that allows fixing specified tensor values during the Jacobian calculation.
Returns
object
The maximum error in between the two Jacobians.

ValueTuple<IList<Server>, object> create_local_cluster(int num_workers, int num_ps, string protocol, object worker_config, object ps_config)

Create and start local servers and return the associated `Server` objects.

"PS" stands for "parameter server": a task responsible for storing and updating the model's parameters. Other tasks send updates to these parameters as they work on optimizing the parameters. This particular division of labor between tasks is not required, but is common for distributed training.

Read more at https://www.tensorflow.org/guide/extend/architecture

![components](https://www.tensorflow.org/images/diag1.svg "components")

Figure illustrates the interaction of these components. "/job:worker/task:0" and "/job:ps/task:0" are both tasks with worker services.

Example:
Parameters
int num_workers
Number of worker servers to start.
int num_ps
Number of PS servers to start.
string protocol
Communication protocol. Allowed values are documented in the documentation of tf.distribute.Server.
object worker_config
(optional) tf.ConfigProto to initialize workers. Can be used to instantiate multiple devices etc.
object ps_config
(optional) tf.ConfigProto to initialize PS servers.
Returns
ValueTuple<IList<Server>, object>
A tuple `(worker_servers, ps_servers)`. `worker_servers` is a list of `num_workers` objects of type tf.distribute.Server (all running locally); and `ps_servers` is a list of `num_ps` objects of similar type.
Show Example
workers, _ = tf.test.create_local_cluster(num_workers=2, num_ps=2) 

worker_sessions = [tf.compat.v1.Session(w.target) for w in workers]

with tf.device("/job:ps/task:0"): ... with tf.device("/job:ps/task:1"): ... with tf.device("/job:worker/task:0"): ... with tf.device("/job:worker/task:1"): ...

worker_sessions[0].run(...)

object create_local_cluster_dyn(object num_workers, object num_ps, ImplicitContainer<T> protocol, object worker_config, object ps_config)

Create and start local servers and return the associated `Server` objects.

"PS" stands for "parameter server": a task responsible for storing and updating the model's parameters. Other tasks send updates to these parameters as they work on optimizing the parameters. This particular division of labor between tasks is not required, but is common for distributed training.

Read more at https://www.tensorflow.org/guide/extend/architecture

![components](https://www.tensorflow.org/images/diag1.svg "components")

Figure illustrates the interaction of these components. "/job:worker/task:0" and "/job:ps/task:0" are both tasks with worker services.

Example:
Parameters
object num_workers
Number of worker servers to start.
object num_ps
Number of PS servers to start.
ImplicitContainer<T> protocol
Communication protocol. Allowed values are documented in the documentation of tf.distribute.Server.
object worker_config
(optional) tf.ConfigProto to initialize workers. Can be used to instantiate multiple devices etc.
object ps_config
(optional) tf.ConfigProto to initialize PS servers.
Returns
object
A tuple `(worker_servers, ps_servers)`. `worker_servers` is a list of `num_workers` objects of type tf.distribute.Server (all running locally); and `ps_servers` is a list of `num_ps` objects of similar type.
Show Example
workers, _ = tf.test.create_local_cluster(num_workers=2, num_ps=2) 

worker_sessions = [tf.compat.v1.Session(w.target) for w in workers]

with tf.device("/job:ps/task:0"): ... with tf.device("/job:ps/task:1"): ... with tf.device("/job:worker/task:0"): ... with tf.device("/job:worker/task:1"): ...

worker_sessions[0].run(...)

string gpu_device_name()

Returns the name of a GPU device if available or the empty string.

object gpu_device_name_dyn()

Returns the name of a GPU device if available or the empty string.

object is_built_with_cuda()

Returns whether TensorFlow was built with CUDA (GPU) support.

object is_built_with_cuda_dyn()

Returns whether TensorFlow was built with CUDA (GPU) support.

object is_built_with_gpu_support()

Returns whether TensorFlow was built with GPU (i.e. CUDA or ROCm) support.

object is_built_with_gpu_support_dyn()

Returns whether TensorFlow was built with GPU (i.e. CUDA or ROCm) support.

object is_built_with_rocm()

Returns whether TensorFlow was built with ROCm (GPU) support.

object is_built_with_rocm_dyn()

Returns whether TensorFlow was built with ROCm (GPU) support.

bool is_gpu_available(bool cuda_only, Nullable<ValueTuple<int, int>> min_cuda_compute_capability)

Returns whether TensorFlow can access a GPU.

Warning: if a non-GPU version of the package is installed, the function would also return False. Use tf.test.is_built_with_cuda to validate if TensorFlow was build with CUDA support.
Parameters
bool cuda_only
limit the search to CUDA GPUs.
Nullable<ValueTuple<int, int>> min_cuda_compute_capability
a (major,minor) pair that indicates the minimum CUDA compute capability required, or None if no requirement.

Note that the keyword arg name "cuda_only" is misleading (since routine will return true when a GPU device is available irrespective of whether TF was built with CUDA support or ROCm support. However no changes here because

++ Changing the name "cuda_only" to something more generic would break backward compatibility

++ Adding an equivalent "rocm_only" would require the implementation check the build type. This in turn would require doing the same for CUDA and thus potentially break backward compatibility

++ Adding a new "cuda_or_rocm_only" would not break backward compatibility, but would require most (if not all) callers to update the call to use "cuda_or_rocm_only" instead of "cuda_only"
Returns
bool
True if a GPU device of the requested kind is available.

object is_gpu_available_dyn(ImplicitContainer<T> cuda_only, object min_cuda_compute_capability)

Returns whether TensorFlow can access a GPU.

Warning: if a non-GPU version of the package is installed, the function would also return False. Use tf.test.is_built_with_cuda to validate if TensorFlow was build with CUDA support.
Parameters
ImplicitContainer<T> cuda_only
limit the search to CUDA GPUs.
object min_cuda_compute_capability
a (major,minor) pair that indicates the minimum CUDA compute capability required, or None if no requirement.

Note that the keyword arg name "cuda_only" is misleading (since routine will return true when a GPU device is available irrespective of whether TF was built with CUDA support or ROCm support. However no changes here because

++ Changing the name "cuda_only" to something more generic would break backward compatibility

++ Adding an equivalent "rocm_only" would require the implementation check the build type. This in turn would require doing the same for CUDA and thus potentially break backward compatibility

++ Adding a new "cuda_or_rocm_only" would not break backward compatibility, but would require most (if not all) callers to update the call to use "cuda_or_rocm_only" instead of "cuda_only"
Returns
object
True if a GPU device of the requested kind is available.

Public properties

PythonFunctionContainer assert_equal_graph_def_fn_ get;

PythonFunctionContainer benchmark_config_fn get;

PythonFunctionContainer compute_gradient_error_fn get;

PythonFunctionContainer compute_gradient_fn get;

PythonFunctionContainer create_local_cluster_fn get;

PythonFunctionContainer get_temp_dir_fn get;

PythonFunctionContainer gpu_device_name_fn get;

PythonFunctionContainer is_built_with_cuda_fn get;

PythonFunctionContainer is_built_with_gpu_support_fn get;

PythonFunctionContainer is_built_with_rocm_fn get;

PythonFunctionContainer is_gpu_available_fn get;

PythonFunctionContainer test_src_dir_path_fn get;