public MapDataset(IDatasetV2 input_dataset,
Func <Tensors, Tensors> map_func,
bool use_inter_op_parallelism = true,
bool preserve_cardinality = false,
bool use_legacy_function = false) : base(input_dataset)
{
var func = new ConcreteFunction($"{map_func.Method.Name}_{Tensorflow.ops.uid_function()}");
func.Enter();
var inputs = new Tensors();
foreach (var input in input_dataset.element_spec)
{
inputs.Add(tf.placeholder(input.dtype, shape: input.shape, name: "arg"));
}
var outputs = map_func(inputs);
func.ToGraph(inputs, outputs);
func.Exit();
structure = func.OutputStructure;
variant_tensor = ops.map_dataset(input_dataset.variant_tensor,
func,
output_types,
output_shapes,
use_inter_op_parallelism: use_inter_op_parallelism,
preserve_cardinality: preserve_cardinality);
}
public FilterDataset(IDatasetV2 input_dataset,
Func <Tensor, bool> predicate_func) : base(input_dataset)
{
Func <Tensors, Tensors> predicate_func_update = x =>
{
var result = predicate_func(x);
return(constant_op.constant(result));
};
var func = new ConcreteFunction($"{predicate_func.Method.Name}_{Tensorflow.ops.uid_function()}");
func.Enter();
var inputs = new Tensors();
foreach (var input in input_dataset.element_spec)
{
inputs.Add(tf.placeholder(input.dtype, shape: input.shape, name: "arg"));
}
var outputs = predicate_func_update(inputs);
func.ToGraph(inputs, outputs);
func.Exit();
structure = func.OutputStructure;
variant_tensor = ops.filter_dataset(input_dataset.variant_tensor,
func,
output_types,
output_shapes);
}
public void FunctionTest()
{
ConcreteFunction target = CreateConcreteFunction();
Function actual;
actual = target.Function;
Assert.IsNotNull(actual);
}
public void ActiveTest()
{
ConcreteFunction target = CreateConcreteFunction();
bool actual;
actual = target.Active;
Assert.AreEqual(true, actual);
}
/// <summary>
/// Creates a dataset containing elements of `input_dataset` matching `predicate`.
/// </summary>
/// <param name="dataset"></param>
/// <param name="predicate"></param>
/// <param name="output_types"></param>
/// <param name="output_shapes"></param>
/// <param name="name"></param>
/// <returns></returns>
public Tensor filter_dataset(Tensor dataset, ConcreteFunction predicate, TF_DataType[] output_types, Shape[] output_shapes,
string name = null)
=> tf.Context.ExecuteOp("FilterDataset", name, new ExecuteOpArgs(dataset, new Tensor[0])
.SetAttributes(new
{
predicate,
output_types,
output_shapes
}));
public FlatMapDataset(IDatasetV2 input_dataset,
Func <Tensor, IDatasetV2> map_func) : base(input_dataset)
{
var func = new ConcreteFunction(map_func, input_dataset.element_spec[0].dtype);
variant_tensor = ops.flat_map_dataset(input_dataset.variant_tensor,
func,
output_types,
output_shapes);
}
/// <summary>
///
/// </summary>
/// <param name="dataset"></param>
/// <param name="iterator"></param>
/// <param name="name"></param>
/// <returns></returns>
public Tensor map_dataset(Tensor dataset, ConcreteFunction f, TF_DataType[] output_types, TensorShape[] output_shapes,
bool use_inter_op_parallelism = true, bool preserve_cardinality = false, string name = null)
=> tf.Context.ExecuteOp("MapDataset", name, new ExecuteOpArgs(dataset, new Tensor[0])
.SetAttributes(new
{
f,
output_types,
output_shapes,
use_inter_op_parallelism,
preserve_cardinality
}));
public MapDataset(IDatasetV2 input_dataset,
Func <Tensor, Tensor> map_func,
bool use_inter_op_parallelism = true,
bool preserve_cardinality = false,
bool use_legacy_function = false) : base(input_dataset)
{
var func = new ConcreteFunction(map_func, input_dataset.element_spec[0].dtype);
variant_tensor = ops.map_dataset(input_dataset.variant_tensor,
func,
output_types,
output_shapes);
}
public override void OnEntry(MethodExecutionArgs args)
{
// TODO: func_name can be cache in FullName + Args
func_name = $"{args.Method.DeclaringType.FullName}.{args.Method.Name}_{ops.uid_function()}";
if (functions.ContainsKey(func_name))
{
function = functions[func_name];
if (args.Arguments[0] is Tensors tensor_inputs)
{
args.ReturnValue = ConvertReturnValue(function.FilteredCall(tensor_inputs));
}
else
{
args.ReturnValue = ConvertReturnValue(function.FilteredCall(args.Arguments.Select(x => x as Tensor).ToArray()));
}
args.FlowBehavior = FlowBehavior.Return;
return;
}
// make function as an Operation by autograph
// need to restore mode when exits
function = new ConcreteFunction(func_name);
function.Enter();
// convert to Tensors
if (args.Arguments[0] is Tensors inputs)
{
originalInputs = inputs;
var new_inputs = inputs.Select(x => tf.placeholder(x.dtype, shape: x.shape, name: "inputs")).ToArray();
args.Arguments[0] = new Tensors(new_inputs);
}
else
{
originalInputs = new Tensors();
// convert args to placeholder
for (var i = 0; i < args.Arguments.Length; i++)
{
if (args.Arguments[i] is EagerTensor tensor)
{
originalInputs.Add(tensor);
args.Arguments[i] = tf.placeholder(tensor.dtype, shape: tensor.shape, name: "inputs");
}
}
}
}
/// <summary>
/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
/// </summary>
/// <param name="dataset"></param>
/// <param name="f"></param>
/// <param name="output_types"></param>
/// <param name="output_shapes"></param>
/// <param name="name"></param>
/// <returns></returns>
public Tensor flat_map_dataset(Tensor dataset, ConcreteFunction f, TF_DataType[] output_types, TensorShape[] output_shapes,
string name = null)
{
if (tf.Context.executing_eagerly())
{
var results = tf.Runner.TFE_FastPathExecute(tf.Context, tf.Context.DeviceName,
"FlatMapDataset", name,
null,
dataset, new Tensor[0],
"f", f,
"output_types", output_types,
"output_shapes", output_shapes);
return(results[0]);
}
throw new NotImplementedException("");
}
public override void OnEntry(MethodExecutionArgs args)
{
func_name = $"autograph_{args.Instance.GetHashCode()}.{args.Method.Name}";
if (functions.ContainsKey(func_name))
{
function = functions[func_name];
if (args.Arguments[0] is Tensors tensor_inputs)
{
args.ReturnValue = ConvertReturnValue(function.Invoke(tensor_inputs));
}
else
{
args.ReturnValue = ConvertReturnValue(function.Invoke(args.Arguments.Select(x => x as Tensor).ToArray()));
}
args.FlowBehavior = FlowBehavior.Return;
return;
}
// make function as an Operation by autograph
// need to restore mode when exits
function = new ConcreteFunction(func_name);
// convert to Tensors
if (args.Arguments[0] is Tensors inputs)
{
originalInputs = inputs;
var new_inputs = inputs.Select(x => tf.placeholder(x.dtype, shape: x.TensorShape, name: "inputs")).ToArray();
args.Arguments[0] = new Tensors(new_inputs);
}
else
{
originalInputs = new Tensors(args.Arguments.Length);
// convert args to placeholder
for (var i = 0; i < args.Arguments.Length; i++)
{
if (args.Arguments[i] is EagerTensor tensor)
{
originalInputs[i] = tensor;
args.Arguments[i] = tf.placeholder(tensor.dtype, shape: tensor.TensorShape, name: "inputs");
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="dataset"></param>
/// <param name="iterator"></param>
/// <param name="name"></param>
/// <returns></returns>
public Tensor map_dataset(Tensor dataset, ConcreteFunction f, TF_DataType[] output_types, TensorShape[] output_shapes,
bool use_inter_op_parallelism = true, bool preserve_cardinality = false, string name = null)
{
if (tf.Context.executing_eagerly())
{
var results = tf.Runner.TFE_FastPathExecute(tf.Context, tf.Context.DeviceName,
"MapDataset", name,
null,
dataset, new Tensor[0],
"f", f,
"output_types", output_types,
"output_shapes", output_shapes,
"use_inter_op_parallelism", use_inter_op_parallelism,
"preserve_cardinality", preserve_cardinality);
return(results[0]);
}
throw new NotImplementedException("");
}
public ParallelMapDataset(IDatasetV2 input_dataset,
Func <Tensors, Tensors> map_func,
int num_parallel_calls = -1,
bool use_inter_op_parallelism = true,
bool preserve_cardinality = false,
bool use_legacy_function = false) : base(input_dataset)
{
var func = new ConcreteFunction(map_func,
input_dataset.element_spec.Select(x => x.dtype).ToArray(),
input_dataset.element_spec.Select(x => x.shape).ToArray());
structure = func.OutputStructure;
var _num_parallel_calls = tf.convert_to_tensor(num_parallel_calls, dtype: tf.int64,
name: "num_parallel_calls");
variant_tensor = ops.parallel_map_dataset_v2(input_dataset.variant_tensor,
_num_parallel_calls,
func,
output_types,
output_shapes);
}
public MapDataset(IDatasetV2 input_dataset,
Func <Tensor, Tensor> map_func,
bool use_inter_op_parallelism = true,
bool preserve_cardinality = false,
bool use_legacy_function = false) : base(input_dataset)
{
using var func = new ConcreteFunction($"autograph_{map_func.Method.Name}");
var input = tf.placeholder(input_dataset.element_spec[0].dtype);
var output = map_func(input);
func.ToGraph(input, output);
structure = func.OutputStructure;
variant_tensor = ops.map_dataset(input_dataset.variant_tensor,
func,
output_types,
output_shapes,
use_inter_op_parallelism: use_inter_op_parallelism,
preserve_cardinality: preserve_cardinality);
}
/// <summary>
/// Initializes a new instance of the AppResult class.
/// </summary>
/// <param name="cncFun">Concrete Function</param>
/// <param name="cncType">Concrete Type</param>
/// <param name="cncTypes">List of Concrete types</param>
public AppResult(ConcreteFunction cncFun, ConcreteType cncType, List<ConcreteType> cncTypes)
{
this.CncFun = cncFun;
this.CncType = cncType;
this.CncTypes = cncTypes;
}
/// <summary>
/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
/// </summary>
/// <param name="dataset"></param>
/// <param name="f"></param>
/// <param name="output_types"></param>
/// <param name="output_shapes"></param>
/// <param name="name"></param>
/// <returns></returns>
public Tensor flat_map_dataset(Tensor dataset, ConcreteFunction f, TF_DataType[] output_types, TensorShape[] output_shapes,
string name = null)
=> tf.Context.ExecuteOp("FlatMapDataset", name, new ExecuteOpArgs(dataset, new Tensor[0])
.SetAttributes(new { f, output_types, output_shapes }));
/// <summary>
/// Creates a dataset that applies `f` to the outputs of `input_dataset`.
/// </summary>
/// <param name="dataset"></param>
/// <param name="num_parallel_calls"></param>
/// <param name="f"></param>
/// <param name="output_types"></param>
/// <param name="output_shapes"></param>
/// <param name="use_inter_op_parallelism"></param>
/// <param name="name"></param>
/// <returns></returns>
public Tensor parallel_map_dataset_v2(Tensor dataset, Tensor num_parallel_calls, ConcreteFunction f,
TF_DataType[] output_types, TensorShape[] output_shapes,
bool use_inter_op_parallelism = true,
string deterministic = "default",
bool preserve_cardinality = false,
string name = null)
=> tf.Context.ExecuteOp("ParallelMapDatasetV2", name,
new ExecuteOpArgs(dataset, new Tensor[0], num_parallel_calls)
.SetAttributes(new
{
f,
output_types,
output_shapes,
use_inter_op_parallelism,
deterministic,
preserve_cardinality
}));
