From 3bd928cabb85e64a1695e7e677b131a4aeeff8e2 Mon Sep 17 00:00:00 2001 From: Oceania2018 Date: Tue, 9 Apr 2019 00:12:05 -0500 Subject: [PATCH] _random still in progress. overload random_uniform. add more on random_seed.get_seed. --- .../_InitializeClustersOpFactory.cs | 10 +++++- .../Framework/random_seed.py.cs | 7 +++- .../Operations/embedding_ops.cs | 34 +++++++++++++++++++ .../Operations/gen_random_ops.py.cs | 24 +++++++++++++ .../Operations/random_ops.py.cs | 25 ++++++++++++++ 5 files changed, 98 insertions(+), 2 deletions(-) diff --git a/src/TensorFlowNET.Core/Clustering/_InitializeClustersOpFactory.cs b/src/TensorFlowNET.Core/Clustering/_InitializeClustersOpFactory.cs index 1cfb85a1..91a2acfa 100644 --- a/src/TensorFlowNET.Core/Clustering/_InitializeClustersOpFactory.cs +++ b/src/TensorFlowNET.Core/Clustering/_InitializeClustersOpFactory.cs @@ -121,7 +121,15 @@ namespace Tensorflow.Clustering private Tensor _random() { - throw new NotImplementedException(""); + var reshape = array_ops.reshape(_num_remaining, new int[] { -1 }); + var cast = math_ops.cast(_num_data, TF_DataType.TF_INT64); + var indices = random_ops.random_uniform( + reshape, + minval: 0, + maxval: cast, + seed: _random_seed, + dtype: TF_DataType.TF_INT64); + return embedding_ops.embedding_lookup(_inputs, indices, partition_strategy: "div"); } } } diff --git a/src/TensorFlowNET.Core/Framework/random_seed.py.cs b/src/TensorFlowNET.Core/Framework/random_seed.py.cs index eb2ea386..df114b23 100644 --- a/src/TensorFlowNET.Core/Framework/random_seed.py.cs +++ b/src/TensorFlowNET.Core/Framework/random_seed.py.cs @@ -6,9 +6,14 @@ namespace Tensorflow { public class random_seed { + private static int DEFAULT_GRAPH_SEED = 87654321; + public static (int?, int?) get_seed(int? op_seed = null) { - return (null, null); + if (op_seed.HasValue) + return (DEFAULT_GRAPH_SEED, 0); + else + return (null, null); } } } diff --git a/src/TensorFlowNET.Core/Operations/embedding_ops.cs b/src/TensorFlowNET.Core/Operations/embedding_ops.cs index 49b2d83d..0983ec77 100644 --- a/src/TensorFlowNET.Core/Operations/embedding_ops.cs +++ b/src/TensorFlowNET.Core/Operations/embedding_ops.cs @@ -37,6 +37,27 @@ namespace Tensorflow }); } + public static Tensor _embedding_lookup_and_transform(Tensor[] @params, + Tensor ids, + string partition_strategy = "mod", + string name = null, + string max_norm = null) + { + return with(ops.name_scope(name, "embedding_lookup", new { @params, ids }), scope => + { + name = scope; + int np = @params.Length; + @params = ops.convert_n_to_tensor_or_indexed_slices(@params, name: "params"); + ids = ops.convert_to_tensor(ids, name: "ids"); + if (np == 1) + { + + } + return array_ops.identity(null); + throw new NotImplementedException("_embedding_lookup_and_transform"); + }); + } + public static Tensor _clip(Tensor @params, Tensor ids, string max_norm = null) { if (max_norm == null) @@ -44,5 +65,18 @@ namespace Tensorflow throw new NotImplementedException("_clip"); } + + public static Tensor embedding_lookup(Tensor[] @params, Tensor ids, + string partition_strategy = "mod", + string name = null, + bool validate_indices = true, + string max_norm = null) + { + return _embedding_lookup_and_transform(@params: @params, + ids: ids, + partition_strategy: partition_strategy, + name: name, + max_norm: max_norm); + } } } diff --git a/src/TensorFlowNET.Core/Operations/gen_random_ops.py.cs b/src/TensorFlowNET.Core/Operations/gen_random_ops.py.cs index 5e9689ab..1e0d3b30 100644 --- a/src/TensorFlowNET.Core/Operations/gen_random_ops.py.cs +++ b/src/TensorFlowNET.Core/Operations/gen_random_ops.py.cs @@ -31,6 +31,30 @@ namespace Tensorflow return _op.outputs[0]; } + /// + /// Outputs random integers from a uniform distribution. + /// + /// + /// + /// + /// + /// + /// + /// + public static Tensor random_uniform_int(Tensor shape, Tensor minval, Tensor maxval, int? seed = 0, int? seed2 = 0, string name = null) + { + if (!seed.HasValue) + seed = 0; + if (!seed2.HasValue) + seed2 = 0; + + var _op = _op_def_lib._apply_op_helper("RandomUniformInt", + name: name, + args: new { shape, minval, maxval, seed, seed2 }); + + return _op.outputs[0]; + } + /// /// Outputs random values from a uniform distribution. /// diff --git a/src/TensorFlowNET.Core/Operations/random_ops.py.cs b/src/TensorFlowNET.Core/Operations/random_ops.py.cs index 2162c1a4..cbbafba0 100644 --- a/src/TensorFlowNET.Core/Operations/random_ops.py.cs +++ b/src/TensorFlowNET.Core/Operations/random_ops.py.cs @@ -64,6 +64,31 @@ namespace Tensorflow }); } + public static Tensor random_uniform(Tensor shape, + long minval = 0, + Tensor maxval = null, + TF_DataType dtype = TF_DataType.TF_FLOAT, + int? seed = null, + string name = null) + { + return with(ops.name_scope(name, "random_uniform", new { shape, minval, maxval }), scope => + { + name = scope; + var minTensor = ops.convert_to_tensor(minval, dtype: dtype, name: "min"); + var maxTensor = ops.convert_to_tensor(maxval, dtype: dtype, name: "max"); + var (seed1, seed2) = random_seed.get_seed(seed); + if (dtype.is_integer()) + { + return gen_random_ops.random_uniform_int(shape, minTensor, maxTensor, seed: seed1, seed2: seed2, name: name); + } + else + { + var rnd = gen_random_ops.random_uniform(shape, dtype); + return math_ops.add(rnd * (maxTensor - minTensor), minTensor, name: name); + } + }); + } + public static Tensor truncated_normal(int[] shape, float mean = 0.0f, float stddev = 1.0f,