public static Tensor conv2d(object parameters) { var args = Python.ConvertToDict(parameters); var input = args["input"]; var filter = args["filter"]; var strides = args["strides"]; var padding = args["padding"]; var name = args["name"]; var data_format = args.ContainsKey("data_format") ? args["data_format"] : "NHWC"; var use_cudnn_on_gpu = args.ContainsKey("use_cudnn_on_gpu") ? args["use_cudnn_on_gpu"] : true; var dilations = args.ContainsKey("dilations") ? args["dilations"] : new int[] { 1, 1, 1, 1 }; var _op = _op_def_lib._apply_op_helper("Conv2D", name: name?.ToString(), args: new { input, filter, strides, padding, use_cudnn_on_gpu, data_format, dilations }); return(_op.outputs[0]); }
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]); }
/// <summary> /// Creates or finds a child frame, and makes `data` available to the child frame. /// </summary> /// <param name="data"></param> /// <param name="frame_name"></param> /// <param name="is_constant"></param> /// <param name="parallel_iterations"></param> /// <param name="name"></param> /// <returns></returns> public static Tensor enter(Tensor data, string frame_name = "frame_name", bool is_constant = false, int parallel_iterations = 10, string name = null) { var _op = _op_def_lib._apply_op_helper("Enter", name, new { data, frame_name, is_constant, parallel_iterations }); 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; } var _op = _op_def_lib._apply_op_helper("RandomStandardNormal", name: name, args: new { shape, dtype, seed, seed2 }); return(_op.output); }
public Tensor Activate(Tensor features, string name = null) { OpDefLibrary _op_def_lib = new OpDefLibrary(); var _op = _op_def_lib._apply_op_helper("Relu", name: name, args: new { features }); return(_op.outputs[0]); }
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[] ctc_greedy_decoder(Tensor inputs, Tensor sequence_length, bool merge_repeated = true, string name = "CTCGreedyDecoder") { var op = _op_def_lib._apply_op_helper("CTCGreedyDecoder", name: name, args: new { inputs, sequence_length, merge_repeated }); /*var decoded_indices = op.outputs[0]; * var decoded_values = op.outputs[1]; * var decoded_shape = op.outputs[2]; * var log_probability = op.outputs[3];*/ return(op.outputs); }
/// <summary> /// Computes rectified linear: `max(features, 0)`. /// </summary> /// <param name="features">A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`, `qint8`.</param> /// <param name="name">A name for the operation (optional).</param> /// <returns>A `Tensor`. Has the same type as `features`.</returns> public static Tensor relu(Tensor features, string name = null) { //_ctx = _context._context //if _ctx is not None and _ctx._eager_context.is_eager: // try: // _result = _pywrap_tensorflow.TFE_Py_FastPathExecute( // _ctx._context_handle, _ctx._eager_context.device_name, "Relu", name, // _ctx._post_execution_callbacks, features) // return _result // except _core._FallbackException: // try: // return relu_eager_fallback( // features, name=name, ctx=_ctx) // except _core._SymbolicException: // pass # Add nodes to the TensorFlow graph. // except (TypeError, ValueError): // result = _dispatch.dispatch( // relu, features=features, name=name) // if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: // return result // raise // except _core._NotOkStatusException as e: // if name is not None: // message = e.message + " name: " + name // else: // message = e.message // _six.raise_from(_core._status_to_exception(e.code, message), None) //# Add nodes to the TensorFlow graph. //try: OpDefLibrary _op_def_lib = new OpDefLibrary(); var _op = _op_def_lib._apply_op_helper("Relu", name: name, args: new { features }); return(_op.outputs[0]); //except (TypeError, ValueError): // result = _dispatch.dispatch( // relu, features=features, name=name) // if result is not _dispatch.OpDispatcher.NOT_SUPPORTED: // return result // raise // var _result = _op.outputs.ToArray(); //_inputs_flat = _op.inputs //_attrs = ("T", _op.get_attr("T")) //_execute.record_gradient( // "Relu", _inputs_flat, _attrs, _result, name) //_result, = _result // return _result; }
/// <summary> /// Computes a 2-D convolution given 4-D `input` and `filter` tensors. /// /// Given an input tensor of shape `[batch, in_height, in_width, in_channels]` /// and a filter / kernel tensor of shape /// `[filter_height, filter_width, in_channels, out_channels]`, this op /// performs the following: /// /// 1. Flattens the filter to a 2-D matrix with shape /// `[filter_height * filter_width * in_channels, output_channels]`. /// 2. Extracts image patches from the input tensor to form a *virtual* /// tensor of shape `[batch, out_height, out_width, /// filter_height * filter_width * in_channels]`. /// 3. For each patch, right-multiplies the filter matrix and the image patch /// vector. /// </summary> /// <param name="parameters"></param> /// <returns></returns> public static Tensor conv2d(Conv2dParams parameters) { var _op = _op_def_lib._apply_op_helper("Conv2D", name: parameters.Name, args: new { input = parameters.Input, filter = parameters.Filter, strides = parameters.Strides, padding = parameters.Padding, use_cudnn_on_gpu = parameters.UseCudnnOnGpu, explicit_paddings = parameters.ExplicitPaddings, data_format = parameters.DataFormat, dilations = parameters.Dilations }); 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 save_v2(Tensor prefix, string[] tensor_names, string[] shape_and_slices, Tensor[] tensors, string name = null) { var _op = _op_def_lib._apply_op_helper("SaveV2", name: name, args: new { prefix, tensor_names, shape_and_slices, tensors }); return(_op); }
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 Operation no_op(string name = null) { var _op = _op_def_lib._apply_op_helper("NoOp", name, null); return(_op); }