/// <summary>
/// Holds state in the form of a tensor that persists across steps.
/// Outputs a ref to the tensor state so it may be read or modified.
/// </summary>
/// <param name="shape">The shape of the variable tensor.</param>
/// <param name="dtype">The type of elements in the variable tensor.</param>
/// <param name="name"></param>
/// <param name="container"></param>
/// <param name="shared_name"></param>
/// <returns></returns>
public static Tensor variable_v2(long[] shape, TF_DataType dtype, string name = "", string container = "", string shared_name = "")
{
var keywords = new Dictionary <string, object>();
keywords.Add("dtype", dtype);
keywords.Add("shape", shape);
keywords.Add("container", container);
keywords.Add("shared_name", shared_name);
var _op = _op_def_lib._apply_op_helper("VariableV2", name: name, keywords: keywords);
var _result = _op.outputs;
var _inputs_flat = _op.inputs;
var _attrs = new Dictionary <string, object>();
_attrs["dtype"] = _op.get_attr <DataType>("dtype");
_attrs["shape"] = _op.get_attr <int[]>("shape");
_attrs["container"] = _op.get_attr <string>("container");
_attrs["shared_name"] = _op.get_attr <string>("shared_name");
_execute.record_gradient("VariableV2", _inputs_flat, _attrs, _result, name);
return(new Tensor(_op, 0, dtype));
}
public Tensor decode_jpeg(Tensor contents,
int channels = 0,
int ratio = 1,
bool fancy_upscaling = true,
bool try_recover_truncated = false,
float acceptable_fraction = 1,
string dct_method = "",
string name = "")
{
// Add nodes to the TensorFlow graph.
if (tf.context.executing_eagerly())
{
throw new NotImplementedException("decode_jpeg");
}
else
{
var _op = _op_def_lib._apply_op_helper("DecodeJpeg", name: name, args: new
{
contents,
channels,
ratio,
fancy_upscaling,
try_recover_truncated,
acceptable_fraction,
dct_method
});
return(_op.outputs[0]);
}
}
public static Operation _assert(Tensor condition, object[] data, int?summarize = 3, string name = null)
{
if (!summarize.HasValue)
{
summarize = 3;
}
var _op = _op_def_lib._apply_op_helper("Assert", name, args: new { condition, data, summarize });
return(_op);
}
public static Operation assign_variable_op(Tensor resource, Tensor value, string name = null)
{
if (tf.context.executing_eagerly())
{
var _result = wrap_tfe_src.TFE_FastPathExecute(tf.context, tf.context.device_name,
"AssignVariableOp", name, null,
resource, value);
return(_result);
}
var _op = _op_def_lib._apply_op_helper("AssignVariableOp", name, new { resource, value });
return(_op);
}
public static Tensor placeholder(TF_DataType dtype, TensorShape shape = null, string name = "")
{
var _op = _op_def_lib._apply_op_helper("Placeholder", args: new { dtype, shape });
var _result = _op.outputs;
var _inputs_flat = _op.inputs;
var _attrs = new Dictionary <string, object>();
_attrs["dtype"] = _op.get_attr <DataType>("dtype");
_attrs["shape"] = _op.get_attr <int[]>("shape");
_execute.record_gradient("Placeholder", _inputs_flat, _attrs, _result, name);
return(new Tensor(_op, 0, dtype));
}
public static Tensor dynamic_stitch(Tensor[] indices, Tensor[] data, string name = null)
{
var _attr_N = indices.Length;
var _op = _op_def_lib._apply_op_helper("DynamicStitch", name, new { indices, data });
return(_op.outputs[0]);
}
public static Tensor placeholder(TF_DataType dtype, TensorShape shape = null)
{
/*var g = ops.get_default_graph();
* var op = new Operation(g, "Placeholder", "feed");
*
* var tensor = new Tensor(op, 0, dtype);
*
* return tensor;*/
var keywords = new Dictionary <string, object>();
keywords.Add("dtype", dtype);
keywords.Add("shape", shape);
var _op = _op_def_lib._apply_op_helper("Placeholder", keywords: keywords);
var _result = _op.outputs;
var _inputs_flat = _op.inputs;
var _attrs = new Dictionary <string, object>();
_attrs["dtype"] = _op.get_attr("dtype");
_attrs["shape"] = _op.get_attr("shape");
var tensor = new Tensor(_op, 0, dtype);
return(tensor);
}
/// <summary>
/// Outputs random values from a normal distribution.
/// </summary>
/// <param name="shape"></param>
/// <param name="dtype"></param>
/// <param name="seed"></param>
/// <param name="seed2"></param>
/// <param name="name"></param>
/// <returns></returns>
public static Tensor random_standard_normal(Tensor shape, TF_DataType dtype = TF_DataType.DtInvalid, int?seed = null, int?seed2 = null, string name = null)
{
if (!seed.HasValue)
{
seed = 0;
}
if (!seed2.HasValue)
{
seed2 = 0;
}
var _op = _op_def_lib._apply_op_helper("RandomStandardNormal",
name: name,
args: new { shape, dtype, seed, seed2 });
return(_op.outputs[0]);
}
public static Tensor placeholder(TF_DataType dtype, TensorShape shape = null)
{
var keywords = new Dictionary <string, object>();
keywords.Add("dtype", dtype);
keywords.Add("shape", shape);
var _op = _op_def_lib._apply_op_helper("Placeholder", keywords: keywords);
var _result = _op.outputs;
var _inputs_flat = _op.inputs;
var _attrs = new Dictionary <string, object>();
_attrs["dtype"] = _op.get_attr("dtype");
_attrs["shape"] = _op.get_attr("shape");
return(new Tensor(_op, 0, dtype));
}
/// <summary>
/// Converts a sparse representation into a dense tensor.
/// </summary>
/// <param name="sparse_indices"></param>
/// <param name="output_shape"></param>
/// <param name="sparse_values"></param>
/// <param name="default_value"></param>
/// <param name="validate_indices"></param>
/// <param name="name"></param>
/// <returns></returns>
public static Tensor sparse_to_dense <T>(Tensor sparse_indices,
int[] output_shape,
T sparse_values,
T default_value,
bool validate_indices = true,
string name = null)
{
var _op = _op_def_lib._apply_op_helper("SparseToDense", name, args: new
{
sparse_indices,
output_shape,
sparse_values,
default_value,
validate_indices
});
return(_op.output);
}
/// <summary>
/// Holds state in the form of a tensor that persists across steps.
/// Outputs a ref to the tensor state so it may be read or modified.
/// </summary>
/// <param name="shape">The shape of the variable tensor.</param>
/// <param name="dtype">The type of elements in the variable tensor.</param>
/// <param name="name"></param>
/// <param name="container"></param>
/// <param name="shared_name"></param>
/// <returns></returns>
public static Tensor variable_v2(long[] shape, TF_DataType dtype, string name = null, string container = "", string shared_name = "")
{
var _op = _op_def_lib._apply_op_helper("VariableV2", name: name, args: new { dtype, shape, container, shared_name });
var _result = _op.outputs;
var _inputs_flat = _op.inputs;
var _attrs = new Dictionary <string, object>();
_attrs["dtype"] = _op.get_attr("dtype");
_attrs["shape"] = _op.get_attr("shape");
_attrs["container"] = _op.get_attr("container");
_attrs["shared_name"] = _op.get_attr("shared_name");
_execute.record_gradient("VariableV2", _inputs_flat, _attrs, _result, name);
return(_result[0]);
}
public static Operation assign_variable_op(Tensor resource, Tensor value, string name = null)
{
if (tf.context.executing_eagerly())
{
var inputs = EagerTensorPass.From(resource, value);
Status status = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name,
"AssignVariableOp", name,
inputs.Points, inputs.Length,
null, null,
null, 0);
status.Check(true);
return(null);
}
var _op = _op_def_lib._apply_op_helper("AssignVariableOp", name, new { resource, value });
return(_op);
}
public static Tensor add(Tensor x, Tensor y)
{
var keywords = new Dictionary <string, object>();
keywords.Add("x", x);
keywords.Add("y", y);
var _op = _op_def_lib._apply_op_helper("Add", keywords: keywords);
return(_op.outputs[0]);
}
private static ResourceVariable less <Tx, Ty>(Tx x, Ty y, string name = null)
{
if (tf.context.executing_eagerly())
{
var results = EagerTensorPass.Create();
var inputs = EagerTensorPass.From(x, y);
Status status = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name,
"Less", name,
inputs.Points, inputs.Length,
null, null,
results.Points, results.Length);
status.Check(true);
return(tf.Variable(results[0].Resolve()));
}
var _op = _op_def_lib._apply_op_helper("Less", name: name, args: new { x, y });
return(tf.Variable(_op.outputs[0]));
}
public static Operation assign_variable_op(Tensor resource, Tensor value, string name = null)
{
if (tf.context.executing_eagerly())
{
Status status = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name,
"AssignVariableOp", name,
new IntPtr[]
{
resource as EagerTensor,
value as EagerTensor
}, 2, null,
null, 0);
status.Check(true);
return(null);
}
var _op = _op_def_lib._apply_op_helper("AssignVariableOp", name, new { resource, value });
return(_op);
}
public static Tensor apply_gradient_descent(RefVariable var, Tensor alpha, Tensor delta, bool use_locking = false, string name = "")
{
var _op = _op_def_lib._apply_op_helper("ApplyGradientDescent", name, new
{
var,
alpha,
delta,
use_locking
});
return(_op.outputs[0]);
}
/// <summary>
/// Outputs random values from a normal distribution.
/// </summary>
/// <param name="shape"></param>
/// <param name="dtype"></param>
/// <param name="seed"></param>
/// <param name="seed2"></param>
/// <param name="name"></param>
/// <returns></returns>
public static Tensor random_standard_normal(Tensor shape, TF_DataType dtype = TF_DataType.DtInvalid, int?seed = null, int?seed2 = null, string name = null)
{
if (!seed.HasValue)
{
seed = 0;
}
if (!seed2.HasValue)
{
seed2 = 0;
}
if (tf.context.executing_eagerly())
{
using var status = new Status();
EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name,
"RandomStandardNormal", name, new IntPtr[]
{
shape as EagerTensor,
}, 1,
op => wrap_tfe_src.SetOpAttrs(op,
"seed", seed,
"seed2", seed2,
"dtype", dtype),
status);
status.Check(true);
return(tensor);
}
var _op = _op_def_lib._apply_op_helper("RandomStandardNormal",
name: name,
args: new { shape, dtype, seed, seed2 });
return(_op.output);
}
/// <summary>
/// Outputs random values from a normal distribution.
/// </summary>
/// <param name="shape"></param>
/// <param name="dtype"></param>
/// <param name="seed"></param>
/// <param name="seed2"></param>
/// <param name="name"></param>
/// <returns></returns>
public static Tensor random_standard_normal(Tensor shape, TF_DataType dtype = TF_DataType.DtInvalid, int?seed = null, int?seed2 = null, string name = null)
{
if (!seed.HasValue)
{
seed = 0;
}
if (!seed2.HasValue)
{
seed2 = 0;
}
if (tf.context.executing_eagerly())
{
var results = new[] { new EagerTensor() };
Status status = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name,
"RandomStandardNormal", name, new IntPtr[]
{
shape as EagerTensor,
}, 1,
op => wrap_tfe_src.SetOpAttrs(op,
"seed", seed,
"seed2", seed2,
"dtype", dtype),
results.Select(x => x.EagerTensorHandle).ToArray(), results.Length);
status.Check(true);
return(results[0].Resolve());
}
var _op = _op_def_lib._apply_op_helper("RandomStandardNormal",
name: name,
args: new { shape, dtype, seed, seed2 });
return(_op.output);
}
public static Tensor add(Tensor x, Tensor y)
{
var keywords = new Dictionary <string, object>();
keywords.Add("x", x);
keywords.Add("y", y);
var _op = _op_def_lib._apply_op_helper("Add", name: "add", keywords: keywords);
return(new Tensor(_op, 0, _op.OutputType(0)));
}
public static Tensor substr(Tensor input, int pos, int len,
string name = null, string @uint = "BYTE")
{
var _op = _op_def_lib._apply_op_helper("Substr", name: name, args: new
{
input,
pos,
len,
unit = @uint
});
return(_op.output);
}
public static Tensor apply_adam(RefVariable var, RefVariable m, RefVariable v, Tensor beta1_power, Tensor beta2_power,
Tensor lr, Tensor beta1, Tensor beta2, Tensor epsilon, Tensor grad,
bool use_locking = false, bool use_nesterov = false, string name = null)
{
var _op = _op_def_lib._apply_op_helper("ApplyAdam", name, new
{
var,
m,
v,
beta1_power,
beta2_power,
lr,
beta1,
beta2,
epsilon,
grad,
use_locking,
use_nesterov
});
return(_op.outputs[0]);
}
public static Tensor add(Tensor a, Tensor b)
{
var keywords = new Dictionary <string, object>();
keywords.Add("x", a);
keywords.Add("y", b);
var _op = _op_def_lib._apply_op_helper("Add", name: "add", keywords: keywords);
var tensor = new Tensor(_op, 0, TF_DataType.TF_FLOAT);
return(tensor);
}
/// <summary>
/// Outputs random values from a normal distribution.
/// </summary>
/// <param name="shape"></param>
/// <param name="dtype"></param>
/// <param name="seed"></param>
/// <param name="seed2"></param>
/// <param name="name"></param>
/// <returns></returns>
public static Tensor random_standard_normal(Tensor shape, TF_DataType dtype = TF_DataType.DtInvalid, int?seed = null, int?seed2 = null, string name = null)
{
if (!seed.HasValue)
{
seed = 0;
}
if (!seed2.HasValue)
{
seed2 = 0;
}
if (tf.context.executing_eagerly())
{
var results = EagerTensorPass.Create();
var attrs = new object[]
{
"seed", seed,
"seed2", seed2,
"dtype", dtype
};
var inputs = EagerTensorPass.From(shape);
Status status = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name,
"RandomStandardNormal", name,
inputs.Points, inputs.Length,
wrap_tfe_src.SetOpAttrs2(attrs),
op => wrap_tfe_src.SetOpAttrs(op, attrs),
results.Points, results.Length);
status.Check(true);
return(results[0].Resolve());
}
var _op = _op_def_lib._apply_op_helper("RandomStandardNormal",
name: name,
args: new { shape, dtype, seed, seed2 });
return(_op.output);
}
public static Tensor expand_dims(Tensor input, int axis, string name = null)
{
var _op = _op_def_lib._apply_op_helper("ExpandDims", name: name, args: new { input, dim = axis });
return(_op.outputs[0]);
}
public static Tensor _all(Tensor input, Tensor axis, bool keep_dims = false, string name = null)
{
var _op = _op_def_lib._apply_op_helper("All", name, args: new { input, reduction_indices = axis, keep_dims = keep_dims });
return(_op.outputs[0]);
}
public static Operation no_op(string name = "")
{
var _op = _op_def_lib._apply_op_helper("NoOp", name);
return(_op);
}
public static Tensor add(Tensor x, Tensor y, string name = "")
{
var _op = _op_def_lib._apply_op_helper("Add", name, args: new { x, y });
return(_op.outputs[0]);
}
public static Tensor greater <Tx, Ty>(Tx x, Ty y, string name = "")
{
var _op = _op_def_lib._apply_op_helper("Greater", name: name, args: new { x, y });
return(_op.outputs[0]);
}
public static Operation assign_variable_op(Tensor resource, Tensor value, string name = null)
{
var _op = _op_def_lib._apply_op_helper("AssignVariableOp", name, new { resource, value });
return(_op);
}
public static Tensor batch_to_space_nd <T>(T input, int[] block_shape, int[,] crops, string name = null)
{
var _op = _op_def_lib._apply_op_helper("BatchToSpaceND", name: name, args: new { input, block_shape, crops });
return(_op.output);
}
