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