Fix SR-CNN missing anomalies when Period > 0 (#7610)

## Root cause

Two domain-mismatch bugs in the `Period > 0` code path of
`SrCnnEntireModeler`:

**1. `Train()` — z-score statistics computed in the wrong domain.**
`_mean` / `_std` were computed from the raw input series *before*
deseasonality ran. The z-score "false anomaly" filter inside
`SpectralResidual` then compared `_seriesToDetect[i]` (the
deseasonalized residual) against those raw-domain stats, producing
meaningless z-scores that suppressed real anomalies.

**2. `GetMarginPeriod()` — `CalculateAnomalyScore` called with `exp` in
the wrong domain.**
`_ifftRe[i]` was passed as the expected-value argument.
`CalculateAnomalyScore` computes `|exp - value| / unit`, which is only
meaningful when both arguments share a domain.

In the no-period sibling `GetMargin()`, this call is correct:
`CalculateExpectedValueByFft(_deAnomalyData)` is invoked immediately
beforehand and overwrites `_ifftRe` with the raw-domain expected value
of the de-anomalized series — so `_ifftRe[i]` and `values[i]` share a
domain there.

`GetMarginPeriod()` was added later (#5202) and reused the same call
shape without that prior overwrite. In the period > 0 path `_ifftRe`
holds the SR saliency map's real component computed on the
deseasonalized residual series, not a raw-domain expected value. The
resulting score collapses to roughly `|raw_value| / unit` — proportional
to raw magnitude rather than deviation from expectation — so real
anomalies often score near zero. This looks like a copy-paste of the
no-period call site without re-deriving what `_ifftRe` actually holds in
the new path.

## Fix

1. Move the `sum` / `_mean` / `_std` computation in `Train()` to *after*
the deseasonality call and compute the statistics against
`_seriesToDetect` (the same series SR will actually score).
2. In `GetMarginPeriod()` pass `results[i][3]` (the raw-domain expected
value just produced by `GetExpectedValuePeriod`) instead of
`_ifftRe[i]`.

The no-period path (`Train` with `_period == 0` and `GetMargin`) is
correct as written and is unchanged.

## Test

Adds `TestSrCnnAnomalyDetectorPhoneCalls`, ported from the
[dotnet/samples PhoneCallsAnomalyDetection
tutorial](https://learn.microsoft.com/dotnet/machine-learning/tutorials/phone-calls-anomaly-detection).
Data file is taken verbatim from
[dotnet/samples](https://github.com/dotnet/samples/tree/main/machine-learning/tutorials/PhoneCallsAnomalyDetection/Data).

The test asserts `DetectSeasonality` returns 7 and that
`DetectEntireAnomalyBySrCnn` flags exactly indices `{28, 44, 56, 70}`.
Prior to this fix the same call detects zero anomalies on the same
input.

`Sensitivity = 87.0` is used to obtain the boundary width the tutorial
was originally calibrated for under the v1.5.2 `_factors` table; the
table was rewritten in #5436, so the tutorial's literal `Sensitivity =
64.0` now produces a much wider boundary that masks all but the
strongest spike at index 28.

---------

Co-authored-by: Matous Kozak <55735845+matouskozak@users.noreply.github.com>
Co-authored-by: Matous Kozak <matouskozak@seznam.cz>
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: 3 people

src/Microsoft.ML.TimeSeries/SrCnnEntireAnomalyDetector.cs

@@ -496,28 +496,32 @@ public void Train(double[] values, ref double[][] results)
                 _minimumOriginValue = Double.MaxValue;
                 _maximumOriginValue = Double.MinValue;
 
-                var sum = 0.0;
-                var squareSum = 0.0;
-
                 Array.Resize(ref _seriesToDetect, values.Length);
                 for (int i = 0; i < values.Length; ++i)
                 {
                     var value = values[i];
                     _seriesToDetect[i] = value;
                     _minimumOriginValue = Math.Min(_minimumOriginValue, value);
                     _maximumOriginValue = Math.Max(_maximumOriginValue, value);
-                    sum += value;
-                    squareSum += value * value;
                 }
 
-                _mean = sum / values.Length;
-                _std = Math.Sqrt((squareSum - (sum * sum) / values.Length) / values.Length);
-
                 if (_period > 0)
                 {
                     _deseasonalityFunction.Deseasonality(ref values, _period, ref _seriesToDetect);
                 }
 
+                var sum = 0.0;
+                var squareSum = 0.0;
+                for (int i = 0; i < values.Length; ++i)
+                {
+                    var value = _seriesToDetect[i];
+                    sum += value;
+                    squareSum += value * value;
+                }
+
+                _mean = sum / values.Length;
+                _std = Math.Sqrt((squareSum - (sum * sum) / values.Length) / values.Length);
+
                 SpectralResidual(_seriesToDetect, results, _threshold);
 
                 //Optional Steps
@@ -812,7 +816,7 @@ private void GetMarginPeriod(double[] values, double[][] results, IReadOnlyList<
                 //Step 11: Update Anomaly Score, Expected Value and Boundaries
                 for (int i = 0; i < results.Length; ++i)
                 {
-                    results[i][1] = CalculateAnomalyScore(values[i], _ifftRe[i], _units[i], results[i][0] > 0);
+                    results[i][1] = CalculateAnomalyScore(values[i], results[i][3], _units[i], results[i][0] > 0);
 
                     // adjust the expected value if the point is not anomaly
                     if (results[i][0] == 0)

test/Microsoft.ML.TimeSeries.Tests/TimeSeriesDirectApi.cs

@@ -772,6 +772,77 @@ public void TestSrCnnAnomalyDetectorBigSpike(
 
         }
 
+        private sealed class PhoneCallsData
+        {
+#pragma warning disable CS0649
+            [LoadColumn(0)]
+            public string timestamp;
+
+            [LoadColumn(1)]
+            public double value;
+#pragma warning restore CS0649
+        }
+
+        private sealed class PhoneCallsPrediction
+        {
+            [VectorType(7)]
+            public double[] Prediction { get; set; }
+        }
+
+        [NativeDependencyFact("MklImports")]
+        public void TestSrCnnAnomalyDetectorPhoneCalls()
+        {
+            var mlContext = new MLContext(1);
+
+            var dataPath = GetDataPath("Timeseries", "phone-calls.csv");
+
+            IDataView dataView = mlContext.Data.LoadFromTextFile<PhoneCallsData>(path: dataPath, hasHeader: true, separatorChar: ',');
+
+            int period = mlContext.AnomalyDetection.DetectSeasonality(dataView, nameof(PhoneCallsData.value));
+            Assert.Equal(7, period);
+
+            var options = new SrCnnEntireAnomalyDetectorOptions()
+            {
+                Threshold = 0.3,
+                Sensitivity = 87.0,
+                DetectMode = SrCnnDetectMode.AnomalyAndMargin,
+                Period = period,
+            };
+
+            var outputDataView = mlContext.AnomalyDetection.DetectEntireAnomalyBySrCnn(dataView, nameof(PhoneCallsPrediction.Prediction), nameof(PhoneCallsData.value), options);
+
+            var predictions = mlContext.Data.CreateEnumerable<PhoneCallsPrediction>(
+                outputDataView, reuseRowObject: false);
+
+            var expectedAnomalyScores = new Dictionary<int, double>
+            {
+                { 28, 0.1545 },
+                { 44, 0.2667 },
+                { 56, 0.2154 },
+                { 70, 0.2516 },
+            };
+
+            int k = 0;
+            foreach (var prediction in predictions)
+            {
+                Assert.Equal(7, prediction.Prediction.Length);
+                if (expectedAnomalyScores.TryGetValue(k, out double expectedScore))
+                {
+                    Assert.Equal(1, prediction.Prediction[0]);
+                    Assert.Equal(expectedScore, prediction.Prediction[1], 0.01);
+                }
+                else
+                {
+                    Assert.Equal(0, prediction.Prediction[0]);
+                    Assert.Equal(0, prediction.Prediction[1]);
+                }
+
+                ++k;
+            }
+
+            Assert.Equal(78, k);
+        }
+
         [NativeDependencyTheory("MklImports"), CombinatorialData]
         public void TestSrCnnAnomalyDetectorWithSeasonalAnomalyData(
             [CombinatorialValues(SrCnnDeseasonalityMode.Stl, SrCnnDeseasonalityMode.Mean, SrCnnDeseasonalityMode.Median)] SrCnnDeseasonalityMode mode

test/data/Timeseries/phone-calls.csv

@@ -0,0 +1,79 @@
+timestamp,value
+2018/9/3,36.69670857
+2018/9/4,35.74160571
+2018/9/5,34.11781143
+2018/9/6,33.53363571
+2018/9/7,29.19957714
+2018/9/8,5.18315
+2018/9/9,5.324905714
+2018/9/10,36.69670857
+2018/9/11,35.74160571
+2018/9/12,34.11781143
+2018/9/13,33.53363571
+2018/9/14,29.19957714
+2018/9/15,5.18315
+2018/9/16,5.324905714
+2018/9/17,36.69670857
+2018/9/18,35.74160571
+2018/9/19,34.11781143
+2018/9/20,33.53363571
+2018/9/21,29.19957714
+2018/9/22,5.18315
+2018/9/23,5.324905714
+2018/9/24,36.69670857
+2018/9/25,35.74160571
+2018/9/26,34.11781143
+2018/9/27,33.53363571
+2018/9/28,29.19957714
+2018/9/29,5.18315
+2018/9/30,5.324905714
+2018/10/1,31.34386429
+2018/10/2,36.18100429
+2018/10/3,34.49893429
+2018/10/4,34.18594143
+2018/10/5,29.96867143
+2018/10/6,5.240491429
+2018/10/7,5.304298571
+2018/10/8,37.94839429
+2018/10/9,36.3811
+2018/10/10,35.76107429
+2018/10/11,35.28894143
+2018/10/12,31.08465286
+2018/10/13,5.931802857
+2018/10/14,5.476382857
+2018/10/15,36.23001857
+2018/10/16,35.51714
+2018/10/17,21.95187143
+2018/10/18,31.15111714
+2018/10/19,28.21996429
+2018/10/20,4.532814286
+2018/10/21,5.376088571
+2018/10/22,36.19748286
+2018/10/23,36.05797571
+2018/10/24,35.05092286
+2018/10/25,34.78529
+2018/10/26,31.19532857
+2018/10/27,5.655607143
+2018/10/28,5.925987143
+2018/10/29,26.61867857
+2018/10/30,35.35089571
+2018/10/31,34.09542571
+2018/11/1,28.74181
+2018/11/2,28.20479429
+2018/11/3,4.849405714
+2018/11/4,5.444168571
+2018/11/5,33.21586857
+2018/11/6,35.69544714
+2018/11/7,34.79379714
+2018/11/8,34.26969714
+2018/11/9,30.07392
+2018/11/10,3.18219
+2018/11/11,3.964938571
+2018/11/12,45.21586857
+2018/11/13,35.69544714
+2018/11/14,34.79379714
+2018/11/15,34.26969714
+2018/11/16,30.07392
+2018/11/17,5.266295714
+2018/11/18,5.386695714
+2018/11/19,33.80200857