diff --git a/src/TensorFlowNET.Core/APIs/tf.layers.cs b/src/TensorFlowNET.Core/APIs/tf.layers.cs
index 089dd8a5..dd74de2d 100644
--- a/src/TensorFlowNET.Core/APIs/tf.layers.cs
+++ b/src/TensorFlowNET.Core/APIs/tf.layers.cs
@@ -144,6 +144,20 @@ namespace Tensorflow
return layer.apply(inputs);
}
+ ///
+ /// Densely-connected layer class. aka fully-connected
+ /// `outputs = activation(inputs * kernel + bias)`
+ ///
+ ///
+ /// Python integer, dimensionality of the output space.
+ ///
+ /// Boolean, whether the layer uses a bias.
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
public Tensor dense(Tensor inputs,
int units,
IActivation activation = null,
@@ -160,7 +174,8 @@ namespace Tensorflow
var layer = new Dense(units, activation,
use_bias: use_bias,
bias_initializer: bias_initializer,
- kernel_initializer: kernel_initializer);
+ kernel_initializer: kernel_initializer,
+ trainable: trainable);
return layer.apply(inputs);
}
diff --git a/src/TensorFlowNET.Core/APIs/tf.math.cs b/src/TensorFlowNET.Core/APIs/tf.math.cs
index ec081cc4..985e3f73 100644
--- a/src/TensorFlowNET.Core/APIs/tf.math.cs
+++ b/src/TensorFlowNET.Core/APIs/tf.math.cs
@@ -14,6 +14,8 @@
limitations under the License.
******************************************************************************/
+using Tensorflow.Operations;
+
namespace Tensorflow
{
public partial class tensorflow
@@ -211,6 +213,36 @@ namespace Tensorflow
///
public Tensor _clip_by_value(Tensor t, Tensor clip_value_min, Tensor clip_value_max, string name = null)
=> gen_math_ops._clip_by_value(t, clip_value_min, clip_value_max);
+
+ ///
+ /// Clips tensor values to a specified min and max.
+ ///
+ ///
+ /// A Tensor.
+ ///
+ ///
+ /// A 0-D (scalar) Tensor, or a Tensor with the same shape
+ /// as t. The minimum value to clip by.
+ ///
+ ///
+ /// A 0-D (scalar) Tensor, or a Tensor with the same shape
+ /// as t. The maximum value to clip by.
+ ///
+ ///
+ /// If specified, the created operation in the graph will be this one, otherwise it will be named 'ClipByValue'.
+ ///
+ ///
+ /// A clipped Tensor with the same shape as input 't'.
+ /// The Operation can be fetched from the resulting Tensor, by fetching the Operation property from the result.
+ ///
+ ///
+ /// Given a tensor t, this operation returns a tensor of the same type and
+ /// shape as t with its values clipped to clip_value_min and clip_value_max.
+ /// Any values less than clip_value_min are set to clip_value_min. Any values
+ /// greater than clip_value_max are set to clip_value_max.
+ ///
+ public Tensor clip_by_value (Tensor t, Tensor clip_value_min, Tensor clip_value_max, string name = "ClipByValue")
+ => gen_ops.clip_by_value(t, clip_value_min, clip_value_max, name);
public Tensor sub(Tensor a, Tensor b)
=> gen_math_ops.sub(a, b);
diff --git a/src/TensorFlowNET.Core/APIs/tf.tensor.cs b/src/TensorFlowNET.Core/APIs/tf.tensor.cs
index b553095e..2052de93 100644
--- a/src/TensorFlowNET.Core/APIs/tf.tensor.cs
+++ b/src/TensorFlowNET.Core/APIs/tf.tensor.cs
@@ -18,8 +18,8 @@ namespace Tensorflow
{
public partial class tensorflow
{
- public Tensor convert_to_tensor(object value,
- string name = null) => ops.convert_to_tensor(value, name: name);
+ public Tensor convert_to_tensor(object value, TF_DataType dtype = TF_DataType.DtInvalid, string name = null, TF_DataType preferred_dtype = TF_DataType.DtInvalid)
+ => ops.convert_to_tensor(value, dtype, name, preferred_dtype);
public Tensor strided_slice(Tensor input, Tensor begin, Tensor end, Tensor strides = null,
int begin_mask = 0,
diff --git a/src/TensorFlowNET.Core/Operations/Activation/gen_nn_ops.activations.cs b/src/TensorFlowNET.Core/Operations/Activation/gen_nn_ops.activations.cs
index 80e1c305..788adda4 100644
--- a/src/TensorFlowNET.Core/Operations/Activation/gen_nn_ops.activations.cs
+++ b/src/TensorFlowNET.Core/Operations/Activation/gen_nn_ops.activations.cs
@@ -14,20 +14,192 @@
limitations under the License.
******************************************************************************/
+using System;
+using static Tensorflow.Binding;
+
namespace Tensorflow.Operations.Activation
{
+ public class sigmoid : IActivation
+ {
+ public Tensor Activate(Tensor x, string name = null)
+ {
+ return tf.sigmoid(x);
+ }
+ }
+
+ public class tanh : IActivation
+ {
+ public Tensor Activate(Tensor x, string name = null)
+ {
+ return tf.tanh(x);
+ }
+ }
+
+ public class leakyrelu : IActivation
+ {
+ private readonly float _alpha;
+
+ public leakyrelu(float alpha = 0.3f) {
+ _alpha = alpha;
+ }
+
+ public Tensor Activate(Tensor x, string name = null)
+ {
+ return nn_ops.leaky_relu(x, _alpha);
+ }
+ }
+
+ public class elu : IActivation
+ {
+ private readonly float _alpha;
+
+ public elu(float alpha = 0.1f)
+ {
+ _alpha = alpha;
+ }
+
+ public Tensor Activate(Tensor x, string name = null)
+ {
+ var res = gen_ops.elu(x);
+ if (Math.Abs(_alpha - 0.1f) < 0.00001f)
+ {
+ return res;
+ }
+
+ return array_ops.@where(x > 0, res, _alpha * res);
+ }
+ }
+
+ public class softmax : IActivation
+ {
+ private readonly int _axis;
+
+ /// Initializes a new instance of the class.
+ public softmax(int axis = -1)
+ {
+ _axis = axis;
+ }
+
+ public Tensor Activate(Tensor x, string name = null)
+ {
+ return nn_ops.softmax(x, _axis);
+ }
+ }
+
+ public class softplus : IActivation
+ {
+ public Tensor Activate(Tensor x, string name = null)
+ {
+ return gen_ops.softplus(x);
+ }
+ }
+
+ public class softsign : IActivation
+ {
+ public Tensor Activate(Tensor x, string name = null)
+ {
+ return gen_ops.softsign(x);
+ }
+ }
+
+ public class linear : IActivation
+ {
+ public Tensor Activate(Tensor x, string name = null)
+ {
+ return x;
+ }
+ }
+
+
+ public class exponential : IActivation
+ {
+ public Tensor Activate(Tensor x, string name = null)
+ {
+ return tf.exp(x, name: name);
+ }
+ }
+
+
public class relu : IActivation
{
- public Tensor Activate(Tensor features, string name = null)
+ private readonly float _threshold;
+ private readonly float _alpha;
+ private readonly float? _maxValue;
+
+ public relu(float threshold = 0f, float alpha = 0.2f, float? max_value = null)
+ {
+ _threshold = threshold;
+ _alpha = alpha;
+ _maxValue = max_value;
+ }
+
+ public Tensor Activate(Tensor x, string name = null)
{
- OpDefLibrary _op_def_lib = new OpDefLibrary();
+ //based on keras/backend.py
+ if (Math.Abs(_alpha) > 0.000001f)
+ {
+ if (!_maxValue.HasValue && Math.Abs(_threshold) < 0.0001)
+ {
+ return nn_ops.leaky_relu(x, _alpha);
+ }
+ }
+
+ Tensor negative_part;
+ if (Math.Abs(_threshold) > 0.000001f)
+ {
+ negative_part = gen_ops.relu(-x + _threshold);
+ } else
+ {
+ negative_part = gen_ops.relu(-x + _threshold);
+ }
+
+ if (Math.Abs(_threshold) > 0.000001f)
+ {
+ x = x * math_ops.cast(tf.greater(x, _threshold), TF_DataType.TF_FLOAT);
+ } else if (Math.Abs(_maxValue.Value - 6f) < 0.0001f)
+ {
+ x = gen_ops.relu6(x);
+ } else
+ {
+ x = gen_ops.relu(x);
+ }
+
+ bool clip_max = _maxValue.HasValue;
+ if (clip_max)
+ {
+ Tensor maxval = constant_op.constant(_maxValue, x.dtype.as_base_dtype());
+ var zero = constant_op.constant(0.0f, x.dtype.as_base_dtype());
+ x = gen_ops.clip_by_value(x, zero, maxval);
+ }
- var _op = _op_def_lib._apply_op_helper("Relu", name: name, args: new
+ if (Math.Abs(_alpha) > 0.00001)
{
- features
- });
+ var a = constant_op.constant(_alpha, x.dtype.as_base_dtype());
+ x -= a * negative_part;
+ }
- return _op.outputs[0];
+ return x;
+ }
+ }
+
+ public class selu : IActivation
+ {
+ public Tensor Activate(Tensor x, string name = null)
+ {
+ const float alpha = 1.6732632423543772848170429916717f;
+ const float scale = 1.0507009873554804934193349852946f;
+ return scale * new elu(alpha).Activate(x, name);
+ }
+ }
+
+ public class hard_sigmoid : IActivation
+ {
+ public Tensor Activate(Tensor x, string name = null)
+ {
+ x = (0.2 * x) + 0.5;
+ var zero = tf.convert_to_tensor(0.0f, x.dtype.as_base_dtype());
+ var one = tf.convert_to_tensor(1.0f, x.dtype.as_base_dtype());
+ return tf.clip_by_value(x, zero, one);
}
}
-}
+}
\ No newline at end of file