public static Tensor prod <T1, T2>(T1 input, T2 axis, bool keep_dims = false, string name = null) { if (tf.context.executing_eagerly()) { try { using var status = new Status(); EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "Prod", name, new IntPtr[] { input as EagerTensor, axis as EagerTensor }, 2, op => wrap_tfe_src.SetOpAttrs(op, "keep_dims", keep_dims), status); status.Check(true); return(tensor); } catch (Exception) { return(prod_eager_fallback(input as Tensor, axis as int[], keep_dims, name, tf.context)); } } var _op = _op_def_lib._apply_op_helper("Prod", name, args: new { input, reduction_indices = axis, keep_dims }); 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()) { 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> /// Creates a handle to a Variable resource. /// </summary> /// <param name="dtype"></param> /// <param name="shape"></param> /// <param name="container"></param> /// <param name="shared_name"></param> /// <param name="name"></param> /// <returns></returns> public static Tensor var_handle_op(TF_DataType dtype, TensorShape shape, string container = "", string shared_name = "", string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "VarHandleOp", name, null, 0, op => wrap_tfe_src.SetOpAttrs(op, "container", container, "shared_name", shared_name, "dtype", dtype, "shape", shape.dims), status); status.Check(true); return(tensor); } var _op = _op_def_lib._apply_op_helper("VarHandleOp", name, new { dtype, shape, container, shared_name }); return(_op.output); }
public static Tensor var_is_initialized_op(Tensor resource, string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "VarIsInitializedOp", name, new IntPtr[] { resource as EagerTensor }, 1, null, status); status.Check(true); return(tensor); } var _op = _op_def_lib._apply_op_helper("VarIsInitializedOp", name, new { resource }); return(_op.output); }
public static Tensor strided_slice(Tensor input, Tensor begin, Tensor end, Tensor strides, int begin_mask = 0, int end_mask = 0, int ellipsis_mask = 0, int new_axis_mask = 0, int shrink_axis_mask = 0, string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "StridedSlice", name, new IntPtr[] { input as EagerTensor, begin as EagerTensor, end as EagerTensor, strides as EagerTensor, }, 4, op => wrap_tfe_src.SetOpAttrs(op, "begin_mask", begin_mask, "end_mask", end_mask, "ellipsis_mask", ellipsis_mask, "new_axis_mask", new_axis_mask, "shrink_axis_mask", shrink_axis_mask), status); status.Check(true); return(tensor); } var _op = _op_def_lib._apply_op_helper("StridedSlice", name, new { input, begin, end, strides, begin_mask, end_mask, ellipsis_mask, new_axis_mask, shrink_axis_mask }); return(_op.outputs[0]); }
public static Tensor sqrt(Tensor x, string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "Sqrt", name, new IntPtr[] { x as EagerTensor, }, 1, null, status); status.Check(true); return(tensor); } var _op = _op_def_lib._apply_op_helper("Sqrt", name, args: new { x }); return(_op.outputs[0]); }
/// <summary> /// Add all input tensors element wise. /// </summary> /// <param name="inputs"></param> /// <param name="name"></param> /// <returns></returns> public static Tensor add_n(Tensor[] inputs, string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle _result = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "AddN", name, inputs.Select(x => (x as EagerTensor).EagerTensorHandle).ToArray(), inputs.Length, null, status); status.Check(true); return(_result); } var _op = _op_def_lib._apply_op_helper("AddN", name, args: new { inputs }); return(_op.outputs[0]); }
/// <summary> /// Return a tensor with the same shape and contents as the input tensor or value. /// </summary> /// <param name="input"></param> /// <param name="name"></param> public static Tensor identity(Tensor input, string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "Identity", name, new IntPtr[] { input as EagerTensor }, 1, null, status); status.Check(true); return(tensor); } var _op = _op_def_lib._apply_op_helper("Identity", name, new { input }); return(_op.output); }
public static Tensor add(Tensor x, Tensor y, string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle _result = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "Add", name, new IntPtr[] { x as EagerTensor, y as EagerTensor }, 2, null, status); status.Check(true); return(_result); } var _op = _op_def_lib._apply_op_helper("Add", name, args: new { x, y }); return(_op.output); }
/// <summary> /// Creates a tensor filled with a scalar value. /// </summary> /// <param name="dims">A `Tensor`.</param> /// <param name="value">A `Tensor`. 0-D (scalar). Value to fill the returned tensor.</param> /// <param name="name">A name for the operation (optional).</param> /// <returns>A `Tensor`. Has the same type as `value`.</returns> public static Tensor fill <T>(Tensor dims, T value, string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "Fill", name, new IntPtr[] { dims as EagerTensor, value as EagerTensor }, 2, null, status); status.Check(true); return(tensor); } var _op = _op_def_lib._apply_op_helper("Fill", name, new { dims, value }); return(_op.output); }
/// <summary> /// Concatenates tensors along one dimension. /// </summary> /// <param name="values"></param> /// <param name="axis"></param> /// <param name="name"></param> /// <returns></returns> public static Tensor concat_v2 <T, Ta>(T[] values, Ta axis, string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "ConcatV2", name, new IntPtr[] { values as EagerTensor, axis as EagerTensor }, 2, null, status); status.Check(true); return(tensor); } var _op = _op_def_lib._apply_op_helper("ConcatV2", name: name, args: new { values, axis }); return(_op.output); }
public static Tensor tile <T>(Tensor input, T multiples, string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "Tile", name, new IntPtr[] { input as EagerTensor, multiples as EagerTensor }, 2, null, status); status.Check(true); return(tensor); } var _op = _op_def_lib._apply_op_helper("Tile", name, new { input, multiples }); return(_op.outputs[0]); }
public static Tensor reshape <T1, T2>(T1 tensor, T2 shape, string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle _result = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "Reshape", name, new IntPtr[] { tensor as EagerTensor, shape as EagerTensor }, 2, null, status); status.Check(true); return(_result); } var _op = _op_def_lib._apply_op_helper("Reshape", name, new { tensor, shape }); return(_op.output); }
/// <summary> /// Returns the truth value of (x != y) element-wise. /// </summary> /// <typeparam name="Tx">The type of the x.</typeparam> /// <typeparam name="Ty">The type of the y.</typeparam> /// <param name="x">The x.</param> /// <param name="y">The y.</param> /// <param name="name">The name.</param> /// <returns></returns> public static Tensor not_equal <Tx, Ty>(Tx x, Ty y, string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "NotEqual", name, new IntPtr[] { x as EagerTensor, y as EagerTensor }, 2, null, status); status.Check(true); return(tensor); } var _op = _op_def_lib._apply_op_helper("NotEqual", name, args: new { x, y }); return(_op.output); }
public static Tensor shape(Tensor input, TF_DataType out_type = TF_DataType.TF_INT32, string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "Shape", name, new IntPtr[] { input as EagerTensor, }, 1, op => wrap_tfe_src.SetOpAttrs(op, "out_type", out_type), status); status.Check(true); return(tensor); } var _op = _op_def_lib._apply_op_helper("Shape", name, new { input, out_type }); return(_op.outputs[0]); }
public static Tensor add_v2 <Tx, Ty>(Tx x, Ty y, string name = null) { // forward_compatible(2019, 6, 25): if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "AddV2", name, new IntPtr[] { x as EagerTensor, y as EagerTensor }, 2, null, status); status.Check(true); return(tensor); } var _op = _op_def_lib._apply_op_helper("AddV2", name, args: new { x, y }); return(_op.output); }
/// <summary> /// Reads the value of a variable. /// </summary> /// <param name="resource"></param> /// <param name="dtype"></param> /// <param name="name"></param> /// <returns></returns> public static Tensor read_variable_op(Tensor resource, TF_DataType dtype, string name = null) { if (tf.context.executing_eagerly()) { using var status = new Status(); EagerTensorHandle tensor = c_api.TFE_FastPathExecute(tf.context, tf.context.device_name, "ReadVariableOp", name, new IntPtr[] { resource as EagerTensor }, 1, op => wrap_tfe_src.SetOpAttrs(op, "dtype", dtype), status); status.Check(true); return(tensor); } var _op = _op_def_lib._apply_op_helper("ReadVariableOp", name, new { resource, dtype }); return(_op.output); }