update

Signed-off-by: FL03 <jo3mccain@icloud.com>

Author: FL03

core/src/nn/layer.rs

@@ -25,7 +25,7 @@ mod types {
     #[cfg(feature = "alloc")]
     use alloc::boxed::Box;
     use concision_params::{Params, ParamsBase};
-    use concision_traits::activate::{HeavySide, Linear, ReLU, Sigmoid, TanhActivator};
+    use concision_traits::activate::{HeavySide, HyperbolicTangent, Linear, ReLU, Sigmoid};
 
     /// A type alias for a layer configured to use the [`ParamsBase`] instance
     pub type LayerParamsBase<F, S, D = ndarray::Ix2, A = f32> = LayerBase<F, ParamsBase<S, D, A>>;
@@ -36,7 +36,7 @@ mod types {
     /// A type alias for a [`Layer`] using a sigmoid activation function.
     pub type SigmoidLayer<T> = LayerBase<Sigmoid, T>;
     /// An alias for a [`Layer`] that uses the hyperbolic tangent function.
-    pub type TanhLayer<T> = LayerBase<TanhActivator, T>;
+    pub type TanhLayer<T> = LayerBase<HyperbolicTangent, T>;
     /// A [`Layer`] type using the ReLU activation function.
     pub type ReluLayer<T> = LayerBase<ReLU, T>;
     /// A [`Layer`] type using the heavyside activation function.

core/src/nn/layer/impl_layer.rs

@@ -12,19 +12,19 @@ impl<F, P, A> LayerBase<F, P>
 where
     P: RawParams<Elem = A>,
 {
-    /// create a new [`Layer`] from the given activation function and parameters.
+    /// create a new [`LayerBase`] from the given activation function and parameters.
     pub const fn new(rho: F, params: P) -> Self {
         Self { rho, params }
     }
-    /// create a new [`Layer`] from the given parameters assuming the logical default for
+    /// create a new [`LayerBase`] from the given parameters assuming the logical default for
     /// the activation of type `F`.
     pub fn from_params(params: P) -> Self
     where
         F: Default,
     {
         Self::new(<F>::default(), params)
     }
-    /// create a new [`Layer`] from the given activation function and shape.
+    /// create a new [`LayerBase`] from the given activation function and shape.
     pub fn from_rho<Sh>(rho: F) -> Self
     where
         P: Default,
@@ -47,6 +47,7 @@ where
     pub const fn rho_mut(&mut self) -> &mut F {
         &mut self.rho
     }
+    #[inline]
     /// consumes the current instance and returns another with the given parameters.
     pub fn with_params<Y>(self, params: Y) -> LayerBase<F, Y>
     where
@@ -57,18 +58,19 @@ where
             params,
         }
     }
+    #[inline]
     /// consumes the current instance and returns another with the given activation function.
     /// This is useful during the creation of the model, when the activation function is not known yet.
     pub fn with_rho<G>(self, rho: G) -> LayerBase<G, P>
     where
         G: Activator<P>,
-        F: Activator<P>,
     {
         LayerBase {
             rho,
             params: self.params,
         }
     }
+    #[inline]
     /// apply the configured activation function onto some input, producing some output
     pub fn activate<X, Y>(&self, input: X) -> Y
     where

core/src/nn/layer/impl_layer_repr.rs

@@ -5,7 +5,7 @@
 use super::LayerBase;
 
 use concision_params::{ParamsBase, RawParams};
-use concision_traits::{Activator, Linear, ReLU, Sigmoid, TanhActivator};
+use concision_traits::{Activator, HyperbolicTangent, Linear, ReLU, Sigmoid};
 use ndarray::{ArrayBase, DataOwned, Dimension, RawData, RemoveAxis, ShapeBuilder};
 
 impl<F, S, D, A> LayerBase<F, ArrayBase<S, D, A>>
@@ -27,6 +27,18 @@ where
             params: ArrayBase::default(shape),
         }
     }
+
+    pub fn dim(&self) -> D::Pattern {
+        self.params().dim()
+    }
+
+    pub fn raw_dim(&self) -> D {
+        self.params().raw_dim()
+    }
+
+    pub fn shape(&self) -> &[usize] {
+        self.params().shape()
+    }
 }
 
 impl<F, S, D, E, A> LayerBase<F, ParamsBase<S, D, A>>
@@ -65,6 +77,18 @@ where
     pub const fn weights_mut(&mut self) -> &mut ArrayBase<S, D, A> {
         self.params_mut().weights_mut()
     }
+
+    pub fn dim(&self) -> D::Pattern {
+        self.params().dim()
+    }
+
+    pub fn raw_dim(&self) -> D {
+        self.params().raw_dim()
+    }
+
+    pub fn shape(&self) -> &[usize] {
+        self.params().shape()
+    }
 }
 
 impl<F, P, A> LayerBase<F, P>
@@ -100,15 +124,15 @@ where
     }
 }
 
-impl<A, P> LayerBase<TanhActivator, P>
+impl<A, P> LayerBase<HyperbolicTangent, P>
 where
     P: RawParams<Elem = A>,
 {
-    /// initialize a new layer using a [`HyperbolicTangent`] activation function and the given
+    /// initialize a new layer using a [`TanhActivator`] activation function and the given
     /// parameters.
     pub const fn tanh(params: P) -> Self {
         Self {
-            rho: TanhActivator,
+            rho: HyperbolicTangent,
             params,
         }
     }

traits/src/activate.rs

@@ -104,7 +104,7 @@ activator! {
     pub struct Linear.linear where T: crate::activate::LinearActivation;
     pub struct ReLU.relu where T: crate::activate::ReLUActivation;
     pub struct Sigmoid.sigmoid where T: crate::activate::SigmoidActivation;
-    pub struct TanhActivator.tanh where T: crate::activate::TanhActivation;
+    pub struct HyperbolicTangent.tanh where T: crate::activate::TanhActivation;
     pub struct HeavySide.heavyside where T: crate::activate::HeavysideActivation;
     pub struct Softmax.softmax where T: crate::activate::SoftmaxActivation;
 }