public void ChangePointDetectionWithSeasonality() { var env = new MLContext(); const int ChangeHistorySize = 10; const int SeasonalitySize = 10; const int NumberOfSeasonsInTraining = 5; const int MaxTrainingSize = NumberOfSeasonsInTraining * SeasonalitySize; var data = new List <Data>(); var dataView = env.Data.LoadFromEnumerable(data); for (int j = 0; j < NumberOfSeasonsInTraining; j++) { for (int i = 0; i < SeasonalitySize; i++) { data.Add(new Data(i)); } } for (int i = 0; i < ChangeHistorySize; i++) { data.Add(new Data(i * 100)); } // Convert to statically-typed data view. var staticData = dataView.AssertStatic(env, c => new { Value = c.R4.Scalar }); // Build the pipeline var staticLearningPipeline = staticData.MakeNewEstimator() .Append(r => r.Value.SsaChangePointDetect(95, ChangeHistorySize, MaxTrainingSize, SeasonalitySize)); // Train var detector = staticLearningPipeline.Fit(staticData); // Transform var output = detector.Transform(staticData); // Get predictions var enumerator = env.Data.CreateEnumerable <ChangePointPrediction>(output.AsDynamic, true).GetEnumerator(); ChangePointPrediction row = null; List <double> expectedValues = new List <double>() { 0, -3.31410598754883, 0.5, 5.12000000000001E-08, 0, 1.5700820684432983, 5.2001145245395008E-07, 0.012414560443710681, 0, 1.2854313254356384, 0.28810801662678009, 0.02038940454467935, 0, -1.0950627326965332, 0.36663890634019225, 0.026956459625565483 }; int index = 0; while (enumerator.MoveNext() && index < expectedValues.Count) { row = enumerator.Current; CompareNumbersWithTolerance(expectedValues[index++], row.Data[0], digitsOfPrecision: 5); // Alert CompareNumbersWithTolerance(expectedValues[index++], row.Data[1], digitsOfPrecision: 5); // Raw score CompareNumbersWithTolerance(expectedValues[index++], row.Data[2], digitsOfPrecision: 5); // P-Value score CompareNumbersWithTolerance(expectedValues[index++], row.Data[3], digitsOfPrecision: 5); // Martingale score } }
public void ChangePointDetectionWithSeasonality() { var env = new MLContext(1); const int changeHistorySize = 10; const int seasonalitySize = 10; const int numberOfSeasonsInTraining = 5; const int maxTrainingSize = numberOfSeasonsInTraining * seasonalitySize; var data = new List <Data>(); var dataView = env.Data.LoadFromEnumerable(data); for (int j = 0; j < numberOfSeasonsInTraining; j++) { for (int i = 0; i < seasonalitySize; i++) { data.Add(new Data(i)); } } for (int i = 0; i < changeHistorySize; i++) { data.Add(new Data(i * 100)); } // Build the pipeline var learningPipeline = ML.Transforms.DetectChangePointBySsa("Data", "Value", 95.0d, changeHistorySize, maxTrainingSize, seasonalitySize); // Train var detector = learningPipeline.Fit(dataView); // Transform var output = detector.Transform(dataView); // Get predictions var enumerator = env.Data.CreateEnumerable <ChangePointPrediction>(output, true).GetEnumerator(); ChangePointPrediction row = null; List <double> expectedValues = new List <double>() { 0, -3.31410598754883, 0.5, 5.12000000000001E-08, 0, 1.5700820684432983, 5.2001145245395008E-07, 0.012414560443710681, 0, 1.2854313254356384, 0.28810801662678009, 0.02038940454467935, 0, -1.0950627326965332, 0.36663890634019225, 0.026956459625565483 }; int index = 0; while (enumerator.MoveNext() && index < expectedValues.Count) { row = enumerator.Current; CompareNumbersWithTolerance(expectedValues[index++], row.Data[0], digitsOfPrecision: 5); // Alert CompareNumbersWithTolerance(expectedValues[index++], row.Data[1], digitsOfPrecision: 5); // Raw score CompareNumbersWithTolerance(expectedValues[index++], row.Data[2], digitsOfPrecision: 5); // P-Value score CompareNumbersWithTolerance(expectedValues[index++], row.Data[3], digitsOfPrecision: 5); // Martingale score } }
public void ChangeDetection() { var env = new MLContext(); const int Size = 10; var data = new List <Data>(Size); var dataView = env.Data.LoadFromEnumerable(data); for (int i = 0; i < Size / 2; i++) { data.Add(new Data(5)); } for (int i = 0; i < Size / 2; i++) { data.Add(new Data((float)(5 + i * 1.1))); } // Convert to statically-typed data view. var staticData = dataView.AssertStatic(env, c => new { Value = c.R4.Scalar }); // Build the pipeline var staticLearningPipeline = staticData.MakeNewEstimator() .Append(r => r.Value.IidChangePointDetect(80, Size)); // Train var detector = staticLearningPipeline.Fit(staticData); // Transform var output = detector.Transform(staticData); // Get predictions var enumerator = env.Data.CreateEnumerable <ChangePointPrediction>(output.AsDynamic, true).GetEnumerator(); ChangePointPrediction row = null; List <double> expectedValues = new List <double>() { 0, 5, 0.5, 5.1200000000000114E-08, 0, 5, 0.4999999995, 5.1200000046080209E-08, 0, 5, 0.4999999995, 5.1200000092160303E-08, 0, 5, 0.4999999995, 5.12000001382404E-08 }; int index = 0; while (enumerator.MoveNext() && index < expectedValues.Count) { row = enumerator.Current; Assert.Equal(expectedValues[index++], row.Data[0], precision: 7); Assert.Equal(expectedValues[index++], row.Data[1], precision: 7); Assert.Equal(expectedValues[index++], row.Data[2], precision: 7); Assert.Equal(expectedValues[index++], row.Data[3], precision: 7); } }
public void ChangeDetection() { var env = new MLContext(1); const int Size = 10; var data = new List <Data>(Size); var dataView = env.Data.LoadFromEnumerable(data); for (int i = 0; i < Size / 2; i++) { data.Add(new Data(5)); } for (int i = 0; i < Size / 2; i++) { data.Add(new Data((float)(5 + i * 1.1))); } // Build the pipeline var learningPipeline = ML.Transforms.DetectIidChangePoint("Data", "Value", 80, Size); // Train var detector = learningPipeline.Fit(dataView); // Transform var output = detector.Transform(dataView); // Get predictions var enumerator = env.Data.CreateEnumerable <ChangePointPrediction>(output, true).GetEnumerator(); ChangePointPrediction row = null; List <double> expectedValues = new List <double>() { 0, 5, 0.5, 5.1200000000000114E-08, 0, 5, 0.4999999995, 5.1200000046080209E-08, 0, 5, 0.4999999995, 5.1200000092160303E-08, 0, 5, 0.4999999995, 5.12000001382404E-08 }; int index = 0; while (enumerator.MoveNext() && index < expectedValues.Count) { row = enumerator.Current; Assert.Equal(expectedValues[index++], row.Data[0], precision: 7); Assert.Equal(expectedValues[index++], row.Data[1], precision: 7); Assert.Equal(expectedValues[index++], row.Data[2], precision: 7); Assert.Equal(expectedValues[index++], row.Data[3], precision: 7); } }
private static void PrintPrediction(float value, ChangePointPrediction prediction) => Console.WriteLine("{0}\t{1}\t{2:0.00}\t{3:0.00}\t{4:0.00}", value, prediction.Prediction[0], prediction.Prediction[1], prediction.Prediction[2], prediction.Prediction[3]);
// This example shows change point detection as above, but demonstrates how to train a model // that can run predictions on streaming data, and how to persist the trained model and then re-load it. public static void SsaChangePointDetectorPrediction() { // Create a new ML context, for ML.NET operations. It can be used for exception tracking and logging, // as well as the source of randomness. var ml = new MLContext(); // Generate sample series data with a recurring pattern const int SeasonalitySize = 5; const int TrainingSeasons = 3; const int TrainingSize = SeasonalitySize * TrainingSeasons; var data = new List <SsaChangePointData>(); for (int i = 0; i < TrainingSeasons; i++) { for (int j = 0; j < SeasonalitySize; j++) { data.Add(new SsaChangePointData(j)); } } // Convert data to IDataView. var dataView = ml.Data.LoadFromEnumerable(data); // Setup SsaChangePointDetector arguments var inputColumnName = nameof(SsaChangePointData.Value); var outputColumnName = nameof(ChangePointPrediction.Prediction); // Train the change point detector. ITransformer model = ml.Transforms.SsaChangePointEstimator(outputColumnName, inputColumnName, 95, 8, TrainingSize, SeasonalitySize + 1).Fit(dataView); // Create a prediction engine from the model for feeding new data. var engine = model.CreateTimeSeriesPredictionFunction <SsaChangePointData, ChangePointPrediction>(ml); // Start streaming new data points with no change point to the prediction engine. Console.WriteLine($"Output from ChangePoint predictions on new data:"); Console.WriteLine("Data\tAlert\tScore\tP-Value\tMartingale value"); ChangePointPrediction prediction = null; for (int i = 0; i < 5; i++) { var value = i; prediction = engine.Predict(new SsaChangePointData(value)); Console.WriteLine("{0}\t{1}\t{2:0.00}\t{3:0.00}\t{4:0.00}", value, prediction.Prediction[0], prediction.Prediction[1], prediction.Prediction[2], prediction.Prediction[3]); } // Now stream data points that reflect a change in trend. for (int i = 0; i < 5; i++) { var value = (i + 1) * 100; prediction = engine.Predict(new SsaChangePointData(value)); Console.WriteLine("{0}\t{1}\t{2:0.00}\t{3:0.00}\t{4:0.00}", value, prediction.Prediction[0], prediction.Prediction[1], prediction.Prediction[2], prediction.Prediction[3]); } // Now we demonstrate saving and loading the model. // Save the model that exists within the prediction engine. // The engine has been updating this model with every new data point. var modelPath = "model.zip"; engine.CheckPoint(ml, modelPath); // Load the model. using (var file = File.OpenRead(modelPath)) model = TransformerChain.LoadFrom(ml, file); // We must create a new prediction engine from the persisted model. engine = model.CreateTimeSeriesPredictionFunction <SsaChangePointData, ChangePointPrediction>(ml); // Run predictions on the loaded model. for (int i = 0; i < 5; i++) { var value = (i + 1) * 100; prediction = engine.Predict(new SsaChangePointData(value)); Console.WriteLine("{0}\t{1}\t{2:0.00}\t{3:0.00}\t{4:0.00}", value, prediction.Prediction[0], prediction.Prediction[1], prediction.Prediction[2], prediction.Prediction[3]); } // Output from ChangePoint predictions on new data: // Data Alert Score P-Value Martingale value // 0 0 - 1.01 0.50 0.00 // 1 0 - 0.24 0.22 0.00 // 2 0 - 0.31 0.30 0.00 // 3 0 0.44 0.01 0.00 // 4 0 2.16 0.00 0.24 // 100 0 86.23 0.00 2076098.24 // 200 0 171.38 0.00 809668524.21 // 300 1 256.83 0.01 22130423541.93 <-- alert is on, note that delay is expected // 400 0 326.55 0.04 241162710263.29 // 500 0 364.82 0.08 597660527041.45 <-- saved to disk // 100 0 - 58.58 0.15 1096021098844.34 <-- loaded from disk and running new predictions // 200 0 - 41.24 0.20 97579154688.98 // 300 0 - 30.61 0.24 95319753.87 // 400 0 58.87 0.38 14.24 // 500 0 219.28 0.36 0.05 }