/// <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); }