gavindiaz/QuanTAlib
1
0
Fork 0
mirror of https://github.com/mihakralj/QuanTAlib.git synced 2026-08-20 11:38:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add Tukey's Biweight and WMAPE implementations with comprehensive tests and documentation

Browse Source 
- Introduced Tukey's Biweight as a robust loss function, including mathematical foundation, usage patterns, and performance profile.
- Added WMAPE (Weighted Mean Absolute Percentage Error) implementation, emphasizing its advantages for intermittent demand forecasting.
- Created unit tests for WMAPE covering various scenarios including edge cases and batch calculations.
- Documented both Tukey's Biweight and WMAPE with detailed explanations, properties, and common use cases.
This commit is contained in:
Miha Kralj
2025-12-30 09:27:08 -08:00
parent bf611d319f
commit 6e24fea8b7
35 changed files with 8341 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/errors/rmse/Rmse.cs
+117 -36
View File
@@ -1,5 +1,8 @@
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;
namespace QuanTAlib;
@@ -175,51 +178,31 @@ public sealed class Rmse : AbstractBase
? stackalloc double[period]
: new double[period];
// Pre-compute squared errors using SIMD if available and data is clean
Span<double> sqErrors = len <= StackAllocThreshold
? stackalloc double[len]
: new double[len];
ComputeSquaredErrors(actual, predicted, sqErrors);
// Apply rolling window average with O(1) per element, then sqrt
double sum = 0;
double lastValidActual = 0;
double lastValidPredicted = 0;
for (int k = 0; k < len; k++)
{
if (double.IsFinite(actual[k])) { lastValidActual = actual[k]; break; }
}
for (int k = 0; k < len; k++)
{
if (double.IsFinite(predicted[k])) { lastValidPredicted = predicted[k]; break; }
}
int bufferIndex = 0;
int i = 0;
int warmupEnd = Math.Min(period, len);
for (; i < warmupEnd; i++)
for (int i = 0; i < warmupEnd; i++)
{
double act = actual[i];
double pred = predicted[i];
if (double.IsFinite(act)) lastValidActual = act; else act = lastValidActual;
if (double.IsFinite(pred)) lastValidPredicted = pred; else pred = lastValidPredicted;
double diff = act - pred;
double error = diff * diff;
sum += error;
buffer[i] = error;
sum += sqErrors[i];
buffer[i] = sqErrors[i];
output[i] = Math.Sqrt(sum / (i + 1));
}
int tickCount = 0;
for (; i < len; i++)
for (int i = warmupEnd; i < len; i++)
{
double act = actual[i];
double pred = predicted[i];
if (double.IsFinite(act)) lastValidActual = act; else act = lastValidActual;
if (double.IsFinite(pred)) lastValidPredicted = pred; else pred = lastValidPredicted;
double diff = act - pred;
double error = diff * diff;
sum = sum - buffer[bufferIndex] + error;
buffer[bufferIndex] = error;
double sqError = sqErrors[i];
sum = sum - buffer[bufferIndex] + sqError;
buffer[bufferIndex] = sqError;
bufferIndex++;
if (bufferIndex >= period) bufferIndex = 0;
@@ -236,4 +219,102 @@ public sealed class Rmse : AbstractBase
}
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void ComputeSquaredErrors(
ReadOnlySpan<double> actual,
ReadOnlySpan<double> predicted,
Span<double> sqErrors)
{
int len = actual.Length;
double lastValidActual = 0;
double lastValidPredicted = 0;
// Find first valid values
for (int k = 0; k < len; k++)
{
if (double.IsFinite(actual[k])) { lastValidActual = actual[k]; break; }
}
for (int k = 0; k < len; k++)
{
if (double.IsFinite(predicted[k])) { lastValidPredicted = predicted[k]; break; }
}
// Try SIMD path for clean data (no NaN/Inf)
if (Avx2.IsSupported && len >= Vector256<double>.Count)
{
// Check if data is clean (no NaN/Inf) - sample check
bool dataClean = true;
int checkStep = Math.Max(1, len / 32);
for (int i = 0; i < len && dataClean; i += checkStep)
{
dataClean = double.IsFinite(actual[i]) && double.IsFinite(predicted[i]);
}
if (dataClean)
{
ComputeSquaredErrorsSimd(actual, predicted, sqErrors);
return;
}
}
// Scalar fallback with NaN handling
ComputeSquaredErrorsScalar(actual, predicted, sqErrors, lastValidActual, lastValidPredicted);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void ComputeSquaredErrorsSimd(
ReadOnlySpan<double> actual,
ReadOnlySpan<double> predicted,
Span<double> sqErrors)
{
int len = actual.Length;
int vectorSize = Vector256<double>.Count;
int vectorEnd = len - (len % vectorSize);
int i = 0;
for (; i < vectorEnd; i += vectorSize)
{
Vector256<double> actVec = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(actual.Slice(i)));
Vector256<double> predVec = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(predicted.Slice(i)));
// error = actual - predicted
Vector256<double> errorVec = Avx.Subtract(actVec, predVec);
// sqError = error * error
Vector256<double> sqErrorVec = Avx.Multiply(errorVec, errorVec);
sqErrorVec.StoreUnsafe(ref MemoryMarshal.GetReference(sqErrors.Slice(i)));
}
// Handle remainder with scalar
for (; i < len; i++)
{
double diff = actual[i] - predicted[i];
sqErrors[i] = diff * diff;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void ComputeSquaredErrorsScalar(
ReadOnlySpan<double> actual,
ReadOnlySpan<double> predicted,
Span<double> sqErrors,
double lastValidActual,
double lastValidPredicted)
{
int len = actual.Length;
for (int i = 0; i < len; i++)
{
double act = actual[i];
double pred = predicted[i];
if (double.IsFinite(act)) lastValidActual = act; else act = lastValidActual;
if (double.IsFinite(pred)) lastValidPredicted = pred; else pred = lastValidPredicted;
double diff = act - pred;
sqErrors[i] = diff * diff;
}
}
}