refactor: replace DeepSurvActivation enum with IActivationFunction<T>

Same refactor as DeepHit:
- DeepSurvOptions is now generic DeepSurvOptions<T>
- Activation property is IActivationFunction<T> (default SELU)
- Delete DeepSurvActivation enum entirely
- Delete ApplyActivation/ApplyActivationDerivative scalar switch methods
- Forward pass now uses Engine.TensorMatMul + activation.Forward (SIMD)
- Serialization uses AssemblyQualifiedName + Activator.CreateInstance

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ooples

src/Models/Options/DeepSurvOptions.cs

@@ -1,8 +1,12 @@
+using AiDotNet.ActivationFunctions;
+using AiDotNet.Interfaces;
+
 namespace AiDotNet.Models.Options;
 
 /// <summary>
 /// Configuration options for DeepSurv survival analysis model.
 /// </summary>
+/// <typeparam name="T">The numeric type used for calculations.</typeparam>
 /// <remarks>
 /// <para>
 /// DeepSurv extends the Cox Proportional Hazards model using a deep neural network
@@ -16,17 +20,12 @@ namespace AiDotNet.Models.Options;
 /// - How long until a customer cancels their subscription?
 /// - How long until a patient experiences disease recurrence?
 ///
-/// What makes survival analysis special is that some observations are "censored" -
-/// meaning the event hasn't happened yet when the study ends. For example, if you're
-/// studying customer churn and a customer is still subscribed when the study ends,
-/// you know they survived at least that long, but you don't know when (or if) they'll churn.
-///
 /// DeepSurv uses a neural network to learn complex patterns in your data while properly
 /// handling this censoring. It outputs a "risk score" - higher values mean higher risk
 /// of the event happening sooner.
 /// </para>
 /// </remarks>
-public class DeepSurvOptions
+public class DeepSurvOptions<T>
 {
     /// <summary>
     /// Gets or sets the number of hidden layers.
@@ -71,10 +70,10 @@ public class DeepSurvOptions
     public double L2Regularization { get; set; } = 0.001;
 
     /// <summary>
-    /// Gets or sets the activation function type.
+    /// Gets or sets the activation function for hidden layers.
     /// </summary>
     /// <value>Default is SELU.</value>
-    public DeepSurvActivation Activation { get; set; } = DeepSurvActivation.SELU;
+    public IActivationFunction<T> Activation { get; set; } = new SELUActivation<T>();
 
     /// <summary>
     /// Gets or sets whether to use batch normalization.
@@ -93,34 +92,3 @@ public class DeepSurvOptions
     /// <value>Default is 10. Set to null to disable early stopping.</value>
     public int? EarlyStoppingPatience { get; set; } = 10;
 }
-
-/// <summary>
-/// Activation functions for DeepSurv.
-/// </summary>
-public enum DeepSurvActivation
-{
-    /// <summary>
-    /// Rectified Linear Unit: max(0, x).
-    /// </summary>
-    ReLU,
-
-    /// <summary>
-    /// Scaled Exponential Linear Unit - self-normalizing.
-    /// </summary>
-    SELU,
-
-    /// <summary>
-    /// Exponential Linear Unit.
-    /// </summary>
-    ELU,
-
-    /// <summary>
-    /// Hyperbolic tangent.
-    /// </summary>
-    Tanh,
-
-    /// <summary>
-    /// Leaky ReLU with small negative slope.
-    /// </summary>
-    LeakyReLU
-}

src/Regression/DeepSurv.cs

@@ -99,7 +99,7 @@ public class DeepSurv<T> : AsyncDecisionTreeRegressionBase<T>
     /// <summary>
     /// Configuration options.
     /// </summary>
-    private readonly DeepSurvOptions _options;
+    private readonly DeepSurvOptions<T> _options;
 
     /// <summary>
     /// Random number generator.
@@ -121,11 +121,11 @@ public class DeepSurv<T> : AsyncDecisionTreeRegressionBase<T>
     /// </summary>
     /// <param name="options">Configuration options.</param>
     /// <param name="regularization">Optional regularization.</param>
-    public DeepSurv(DeepSurvOptions? options = null, IRegularization<T, Matrix<T>, Vector<T>>? regularization = null)
+    public DeepSurv(DeepSurvOptions<T>? options = null, IRegularization<T, Matrix<T>, Vector<T>>? regularization = null)
         : base(null, regularization)
     {
         _olsIntercept = NumOps.Zero;
-        _options = options ?? new DeepSurvOptions();
+        _options = options ?? new DeepSurvOptions<T>();
         _weights = [];
         _biases = [];
         _numFeatures = 0;
@@ -383,19 +383,18 @@ private void InitializeNetwork()
             var b = _biases[layer];
             int outputSize = w.Columns;
 
+            var weightTensor = Tensor<T>.FromMatrix(w);
+            var biasTensor = Tensor<T>.FromVector(b).Reshape(1, outputSize);
             var next = new Vector<T>[n];
             for (int i = 0; i < n; i++)
             {
-                next[i] = new Vector<T>(outputSize);
-                for (int j = 0; j < outputSize; j++)
-                {
-                    // Engine-accelerated dot product for input · weights[:,j]
-                    var wCol = new Vector<T>(current[i].Length);
-                    for (int k = 0; k < current[i].Length; k++) wCol[k] = w[k, j];
-                    T sum = NumOps.Add(b[j], Engine.DotProduct(current[i], wCol));
-
-                    next[i][j] = NumOps.FromDouble(ApplyActivation(NumOps.ToDouble(sum)));
-                }
+                // SIMD: output = input @ weights + biases via Engine.TensorMatMul
+                var inputTensor = Tensor<T>.FromVector(current[i]).Reshape(1, current[i].Length);
+                var result = Engine.TensorBroadcastAdd(
+                    Engine.TensorMatMul(inputTensor, weightTensor), biasTensor);
+                // SIMD activation via IActivationFunction.Forward
+                result = _options.Activation.Forward(result);
+                next[i] = result.Reshape(outputSize).ToVector();
             }
 
             hiddenOutputs.Add(current);
@@ -579,37 +578,6 @@ private T FindTimeForHazard(T targetH0)
     }
 
     /// <summary>
-    /// Applies the activation function.
-    /// </summary>
-    private double ApplyActivation(double x)
-    {
-        return _options.Activation switch
-        {
-            DeepSurvActivation.ReLU => Math.Max(0, x),
-            DeepSurvActivation.SELU => x >= 0 ? 1.0507 * x : 1.0507 * 1.6733 * (Math.Exp(x) - 1),
-            DeepSurvActivation.ELU => x >= 0 ? x : Math.Exp(x) - 1,
-            DeepSurvActivation.Tanh => Math.Tanh(x),
-            DeepSurvActivation.LeakyReLU => x >= 0 ? x : 0.01 * x,
-            _ => Math.Max(0, x)
-        };
-    }
-
-    /// <summary>
-    /// Applies the activation function derivative.
-    /// </summary>
-    private double ApplyActivationDerivative(double activated)
-    {
-        return _options.Activation switch
-        {
-            DeepSurvActivation.ReLU => activated > 0 ? 1 : 0,
-            DeepSurvActivation.SELU => activated >= 0 ? 1.0507 : 1.0507 * 1.6733 * Math.Exp(activated / 1.0507),
-            DeepSurvActivation.ELU => activated >= 0 ? 1 : activated + 1,
-            DeepSurvActivation.Tanh => 1 - activated * activated,
-            DeepSurvActivation.LeakyReLU => activated >= 0 ? 1 : 0.01,
-            _ => activated > 0 ? 1 : 0
-        };
-    }
-
     private int[] GetSortedIndices(Vector<T> times)
     {
         return Enumerable.Range(0, times.Length)
@@ -692,7 +660,7 @@ public override byte[] Serialize()
         // Options
         writer.Write(_options.NumHiddenLayers);
         writer.Write(_options.HiddenLayerSize);
-        writer.Write((int)_options.Activation);
+        writer.Write(_options.Activation.GetType().AssemblyQualifiedName ?? _options.Activation.GetType().FullName ?? _options.Activation.GetType().Name);
         writer.Write(_numFeatures);
 
         // Weights and biases
@@ -762,7 +730,11 @@ public override void Deserialize(byte[] modelData)
 
         _options.NumHiddenLayers = reader.ReadInt32();
         _options.HiddenLayerSize = reader.ReadInt32();
-        _options.Activation = (DeepSurvActivation)reader.ReadInt32();
+        string activationTypeName = reader.ReadString();
+        var activationType = Type.GetType(activationTypeName);
+        _options.Activation = activationType is not null
+            ? (IActivationFunction<T>)(Activator.CreateInstance(activationType) ?? new SELUActivation<T>())
+            : new SELUActivation<T>();
         _numFeatures = reader.ReadInt32();
 
         int numLayers = reader.ReadInt32();