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
}
