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