chore: automated dotnet format

src/Interfaces/IGpuOptimizerConfig.cs

@@ -56,7 +56,7 @@ public interface IGpuOptimizerConfig
     /// how to apply its own update, so adding new optimizers doesn't require modifying layer code.
     /// </para>
     /// </remarks>
-    void ApplyUpdate(IDirectGpuBackend backend, IGpuBuffer param, IGpuBuffer gradient, 
+    void ApplyUpdate(IDirectGpuBackend backend, IGpuBuffer param, IGpuBuffer gradient,
         GpuOptimizerState state, int size);
 }
 

src/LossFunctions/DiceLoss.cs

@@ -78,21 +78,21 @@ public override T CalculateLoss(Vector<T> predicted, Vector<T> actual)
     public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> actual)
     {
         ValidateVectorLengths(predicted, actual);
-        
+
         T intersection = NumOps.Zero;
         T sumPredicted = NumOps.Zero;
         T sumActual = NumOps.Zero;
-        
+
         for (int i = 0; i < predicted.Length; i++)
         {
             intersection = NumOps.Add(intersection, NumOps.Multiply(predicted[i], actual[i]));
             sumPredicted = NumOps.Add(sumPredicted, predicted[i]);
             sumActual = NumOps.Add(sumActual, actual[i]);
         }
-        
+
         T denominator = NumOps.Add(sumPredicted, sumActual);
         T twoIntersection = NumOps.Multiply(NumOps.FromDouble(2.0), intersection);
-        
+
         var result = new T[predicted.Length];
         for (int i = 0; i < predicted.Length; i++)
         {
@@ -109,9 +109,9 @@ public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> act
                 )
             );
         }
-        
+
         return new Vector<T>(result);
     }
 
-    
+
 }

src/LossFunctions/FocalLoss.cs

@@ -101,30 +101,30 @@ public override T CalculateLoss(Vector<T> predicted, Vector<T> actual)
     public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> actual)
     {
         ValidateVectorLengths(predicted, actual);
-        
+
         var result = new T[predicted.Length];
-        
+
         for (int i = 0; i < predicted.Length; i++)
         {
             T p = NumericalStabilityHelper.ClampProbability(predicted[i], NumericalStabilityHelper.SmallEpsilon);
             T y = actual[i];
-            
+
             T pt = NumOps.Equals(y, NumOps.One) ? p : NumOps.Subtract(NumOps.One, p);
             T alphaT = NumOps.Equals(y, NumOps.One) ? _alpha : NumOps.Subtract(NumOps.One, _alpha);
-            
+
             T focusingTerm = NumOps.Power(NumOps.Subtract(NumOps.One, pt), _gamma);
             T logPt = NumericalStabilityHelper.SafeLog(pt, NumericalStabilityHelper.SmallEpsilon);
-            
+
             // Derivative of focal loss with respect to p
             T gammaFactor = NumOps.Multiply(_gamma, NumOps.Power(NumOps.Subtract(NumOps.One, pt), NumOps.Subtract(_gamma, NumOps.One)));
             T term1 = NumOps.Multiply(gammaFactor, logPt);
             T term2 = NumOps.Divide(focusingTerm, pt);
-            
+
             T grad = NumOps.Multiply(alphaT, NumOps.Subtract(term1, term2));
-            
+
             result[i] = NumOps.Equals(y, NumOps.One) ? grad : NumOps.Negate(grad);
         }
-        
+
         return new Vector<T>(result).Divide(NumOps.FromDouble(predicted.Length));
     }
 

src/LossFunctions/HingeLoss.cs

@@ -62,13 +62,13 @@ public override T CalculateLoss(Vector<T> predicted, Vector<T> actual)
     public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> actual)
     {
         ValidateVectorLengths(predicted, actual);
-        
+
         var result = new T[predicted.Length];
-        
+
         for (int i = 0; i < predicted.Length; i++)
         {
             T margin = NumOps.Subtract(NumOps.One, NumOps.Multiply(actual[i], predicted[i]));
-            
+
             if (NumOps.GreaterThan(margin, NumOps.Zero))
             {
                 // Derivative is -y when margin > 0
@@ -80,7 +80,7 @@ public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> act
                 result[i] = NumOps.Zero;
             }
         }
-        
+
         return new Vector<T>(result).Divide(NumOps.FromDouble(predicted.Length));
     }
 

src/LossFunctions/HuberLoss.cs

@@ -92,14 +92,14 @@ public override T CalculateLoss(Vector<T> predicted, Vector<T> actual)
     public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> actual)
     {
         ValidateVectorLengths(predicted, actual);
-        
+
         var result = new T[predicted.Length];
-        
+
         for (int i = 0; i < predicted.Length; i++)
         {
             T diff = NumOps.Subtract(predicted[i], actual[i]);
             T absDiff = NumOps.Abs(diff);
-            
+
             if (NumOps.LessThanOrEquals(absDiff, _delta))
             {
                 // Quadratic region: derivative is diff
@@ -111,7 +111,7 @@ public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> act
                 result[i] = NumOps.Multiply(_delta, NumOps.SignOrZero(diff));
             }
         }
-        
+
         return new Vector<T>(result).Divide(NumOps.FromDouble(predicted.Length));
     }
 

src/LossFunctions/LogCoshLoss.cs

@@ -77,9 +77,9 @@ public override T CalculateLoss(Vector<T> predicted, Vector<T> actual)
     public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> actual)
     {
         ValidateVectorLengths(predicted, actual);
-        
+
         var result = new T[predicted.Length];
-        
+
         for (int i = 0; i < predicted.Length; i++)
         {
             T diff = NumOps.Subtract(predicted[i], actual[i]);
@@ -91,7 +91,7 @@ public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> act
                 NumOps.Add(expPos, expNeg)
             );
         }
-        
+
         return new Vector<T>(result).Divide(NumOps.FromDouble(predicted.Length));
     }
 

src/LossFunctions/LossFunctionBase.cs

@@ -54,17 +54,17 @@ public virtual (T Loss, IGpuTensor<T> Gradient) CalculateLossAndGradientGpu(IGpu
         // Default: fall back to CPU
         var predictedCpu = predicted.ToTensor();
         var actualCpu = actual.ToTensor();
-        
+
         var loss = CalculateLoss(predictedCpu.ToVector(), actualCpu.ToVector());
         var gradientCpu = CalculateDerivative(predictedCpu.ToVector(), actualCpu.ToVector());
-        
+
         var gradientTensor = new Tensor<T>(predictedCpu.Shape);
         Array.Copy(gradientCpu.ToArray(), gradientTensor.Data, gradientCpu.Length);
-        
+
         var engine = AiDotNetEngine.Current as DirectGpuTensorEngine;
         var backend = engine?.GetBackend() ?? throw new InvalidOperationException("GPU backend not available");
         var gradientGpu = new GpuTensor<T>(backend, gradientTensor, GpuTensorRole.Gradient);
-        
+
         return (loss, gradientGpu);
     }
 

src/LossFunctions/QuantileLoss.cs

@@ -90,13 +90,13 @@ public override T CalculateLoss(Vector<T> predicted, Vector<T> actual)
     public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> actual)
     {
         ValidateVectorLengths(predicted, actual);
-        
+
         var result = new T[predicted.Length];
-        
+
         for (int i = 0; i < predicted.Length; i++)
         {
             T diff = NumOps.Subtract(actual[i], predicted[i]);
-            
+
             if (NumOps.GreaterThan(diff, NumOps.Zero))
             {
                 // Underestimation: derivative is -quantile
@@ -108,7 +108,7 @@ public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> act
                 result[i] = NumOps.Subtract(NumOps.One, _quantile);
             }
         }
-        
+
         return new Vector<T>(result).Divide(NumOps.FromDouble(predicted.Length));
     }
 

src/LossFunctions/RootMeanSquaredErrorLoss.cs

@@ -42,22 +42,22 @@ public override T CalculateLoss(Vector<T> predicted, Vector<T> actual)
     public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> actual)
     {
         ValidateVectorLengths(predicted, actual);
-        
+
         var diff = predicted - actual;
         var mse = diff.PointwiseMultiply(diff).Average();
         var rmse = NumOps.Sqrt(mse);
-        
+
         if (NumOps.Equals(rmse, NumOps.Zero))
         {
             var zeros = new T[predicted.Length];
             for (int i = 0; i < zeros.Length; i++)
                 zeros[i] = NumOps.Zero;
             return new Vector<T>(zeros);
         }
-        
+
         var n = NumOps.FromDouble(predicted.Length);
         return diff.Divide(NumOps.Multiply(rmse, n));
     }
 
-    
+
 }

src/LossFunctions/SquaredHingeLoss.cs

@@ -68,13 +68,13 @@ public override T CalculateLoss(Vector<T> predicted, Vector<T> actual)
     public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> actual)
     {
         ValidateVectorLengths(predicted, actual);
-        
+
         var result = new T[predicted.Length];
-        
+
         for (int i = 0; i < predicted.Length; i++)
         {
             T margin = NumOps.Subtract(NumOps.One, NumOps.Multiply(actual[i], predicted[i]));
-            
+
             if (NumOps.GreaterThan(margin, NumOps.Zero))
             {
                 // Derivative is -2 * margin * y when margin > 0
@@ -89,7 +89,7 @@ public override Vector<T> CalculateDerivative(Vector<T> predicted, Vector<T> act
                 result[i] = NumOps.Zero;
             }
         }
-        
+
         return new Vector<T>(result).Divide(NumOps.FromDouble(predicted.Length));
     }
 

src/NeuralNetworks/BigGAN.cs

@@ -998,17 +998,17 @@ public Vector<TLoss> CalculateDerivative(Vector<TLoss> predicted, Vector<TLoss>
             // Fall back to CPU for now
             var predictedCpu = predicted.ToTensor();
             var actualCpu = actual.ToTensor();
-            
+
             var loss = CalculateLoss(predictedCpu.ToVector(), actualCpu.ToVector());
             var gradientCpu = CalculateDerivative(predictedCpu.ToVector(), actualCpu.ToVector());
-            
+
             var gradientTensor = new Tensor<TLoss>(predictedCpu.Shape);
             Array.Copy(gradientCpu.ToArray(), gradientTensor.Data, gradientCpu.Length);
-            
+
             var engine = AiDotNetEngine.Current as DirectGpuTensorEngine;
             var backend = engine?.GetBackend() ?? throw new InvalidOperationException("GPU backend not available");
             var gradientGpu = new GpuTensor<TLoss>(backend, gradientTensor, GpuTensorRole.Gradient);
-            
+
             return (loss, gradientGpu);
         }
     }

src/NeuralNetworks/NeuralNetworkBase.cs

@@ -797,7 +797,7 @@ public virtual T TrainBatchGpuDeferred(
         };
 
         T lossValue = NumOps.Zero;
-        
+
         var backend = gpuEngine.GetBackend() as IAsyncGpuBackend;
         if (backend == null)
         {
@@ -861,7 +861,7 @@ public virtual async Task<T> TrainBatchGpuDeferredAsync(
         };
 
         T lossValue = NumOps.Zero;
-        
+
         var backend = gpuEngine.GetBackend() as IAsyncGpuBackend;
         if (backend == null)
         {

src/NeuralNetworks/SAGAN.cs

@@ -683,17 +683,17 @@ public Vector<TLoss> CalculateDerivative(Vector<TLoss> predicted, Vector<TLoss>
             // Fall back to CPU for now
             var predictedCpu = predicted.ToTensor();
             var actualCpu = actual.ToTensor();
-            
+
             var loss = CalculateLoss(predictedCpu.ToVector(), actualCpu.ToVector());
             var gradientCpu = CalculateDerivative(predictedCpu.ToVector(), actualCpu.ToVector());
-            
+
             var gradientTensor = new Tensor<TLoss>(predictedCpu.Shape);
             Array.Copy(gradientCpu.ToArray(), gradientTensor.Data, gradientCpu.Length);
-            
+
             var engine = AiDotNetEngine.Current as DirectGpuTensorEngine;
             var backend = engine?.GetBackend() ?? throw new InvalidOperationException("GPU backend not available");
             var gradientGpu = new GpuTensor<TLoss>(backend, gradientTensor, GpuTensorRole.Gradient);
-            
+
             return (loss, gradientGpu);
         }
     }

src/Optimizers/AMSGradOptimizer.cs

@@ -1,5 +1,5 @@
-using Newtonsoft.Json;
 using AiDotNet.Tensors.Engines.DirectGpu;
+using Newtonsoft.Json;
 
 namespace AiDotNet.Optimizers;
 

src/Optimizers/AdaDeltaOptimizer.cs

@@ -1,5 +1,5 @@
-using Newtonsoft.Json;
 using AiDotNet.Tensors.Engines.DirectGpu;
+using Newtonsoft.Json;
 
 namespace AiDotNet.Optimizers;
 

src/Optimizers/AdaMaxOptimizer.cs

@@ -1,5 +1,5 @@
-using Newtonsoft.Json;
 using AiDotNet.Tensors.Engines.DirectGpu;
+using Newtonsoft.Json;
 
 namespace AiDotNet.Optimizers;
 

src/Optimizers/AdagradOptimizer.cs

@@ -1,5 +1,5 @@
-using Newtonsoft.Json;
 using AiDotNet.Tensors.Engines.DirectGpu;
+using Newtonsoft.Json;
 
 namespace AiDotNet.Optimizers;
 

src/Optimizers/AdamOptimizer.cs

@@ -1,5 +1,5 @@
-using Newtonsoft.Json;
 using AiDotNet.Tensors.Engines.DirectGpu;
+using Newtonsoft.Json;
 
 namespace AiDotNet.Optimizers;
 

src/Optimizers/AdamWOptimizer.cs

@@ -1,5 +1,5 @@
-using Newtonsoft.Json;
 using AiDotNet.Tensors.Engines.DirectGpu;
+using Newtonsoft.Json;
 
 namespace AiDotNet.Optimizers;
 

src/Optimizers/FTRLOptimizer.cs

@@ -1,5 +1,5 @@
-using Newtonsoft.Json;
 using AiDotNet.Tensors.Engines.DirectGpu;
+using Newtonsoft.Json;
 
 namespace AiDotNet.Optimizers;
 

src/Optimizers/GradientDescentOptimizer.cs

@@ -1,5 +1,5 @@
-using Newtonsoft.Json;
 using AiDotNet.Tensors.Engines.DirectGpu;
+using Newtonsoft.Json;
 
 namespace AiDotNet.Optimizers;
 

src/Optimizers/LAMBOptimizer.cs

@@ -1,5 +1,5 @@
-using Newtonsoft.Json;
 using AiDotNet.Tensors.Engines.DirectGpu;
+using Newtonsoft.Json;
 
 namespace AiDotNet.Optimizers;
 

src/Optimizers/LARSOptimizer.cs

@@ -1,5 +1,5 @@
-using Newtonsoft.Json;
 using AiDotNet.Tensors.Engines.DirectGpu;
+using Newtonsoft.Json;
 
 namespace AiDotNet.Optimizers;
 

src/Optimizers/LionOptimizer.cs

@@ -1,5 +1,5 @@
-using Newtonsoft.Json;
 using AiDotNet.Tensors.Engines.DirectGpu;
+using Newtonsoft.Json;
 
 namespace AiDotNet.Optimizers;