public void ChangePointDetectionWithSeasonality()
{
using (var env = new ConsoleEnvironment(conc: 1))
{
const int ChangeHistorySize = 10;
const int SeasonalitySize = 10;
const int NumberOfSeasonsInTraining = 5;
const int MaxTrainingSize = NumberOfSeasonsInTraining * SeasonalitySize;
List <Data> data = new List <Data>();
var dataView = env.CreateStreamingDataView(data);
var args = new SsaChangePointDetector.Arguments()
{
Confidence = 95,
Source = "Value",
Name = "Change",
ChangeHistoryLength = ChangeHistorySize,
TrainingWindowSize = MaxTrainingSize,
SeasonalWindowSize = SeasonalitySize
};
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));
}
// Train
var detector = new SsaChangePointEstimator(env, args).Fit(dataView);
// Transform
var output = detector.Transform(dataView);
// Get predictions
var enumerator = output.AsEnumerable <Prediction>(env, true).GetEnumerator();
Prediction 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;
Assert.Equal(expectedValues[index++], row.Change[0], precision: 7); // Alert
Assert.Equal(expectedValues[index++], row.Change[1], precision: 7); // Raw score
Assert.Equal(expectedValues[index++], row.Change[2], precision: 7); // P-Value score
Assert.Equal(expectedValues[index++], row.Change[3], precision: 7); // Martingale score
}
}
}
public void ChangePointDetectionWithSeasonality()
{
using (var env = new ConsoleEnvironment(conc: 1))
{
const int ChangeHistorySize = 2000;
const int SeasonalitySize = 1000;
const int NumberOfSeasonsInTraining = 5;
const int MaxTrainingSize = NumberOfSeasonsInTraining * SeasonalitySize;
List <Data> data = new List <Data>();
var dataView = env.CreateStreamingDataView(data);
var args = new SsaChangePointDetector.Arguments()
{
Confidence = 95,
Source = "Value",
Name = "Change",
ChangeHistoryLength = ChangeHistorySize,
Data = dataView,
TrainingWindowSize = MaxTrainingSize,
SeasonalWindowSize = SeasonalitySize
};
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));
}
var detector = TimeSeriesProcessing.SsaChangePointDetector(env, args);
var output = detector.Model.Apply(env, dataView);
var enumerator = output.AsEnumerable <Prediction>(env, true).GetEnumerator();
Prediction row = null;
List <double> expectedValues = new List <double>()
{
0, 0, 0.5, 0, 0, 1, 0.15865526383236372,
0, 0, 1.6069464981555939, 0.05652458872960725, 0, 0, 2.0183047652244568, 0.11021633531076747, 0
};
int index = 0;
while (enumerator.MoveNext() && index < expectedValues.Count)
{
row = enumerator.Current;
Assert.Equal(expectedValues[index++], row.Change[0], precision: 7);
Assert.Equal(expectedValues[index++], row.Change[1], precision: 7);
Assert.Equal(expectedValues[index++], row.Change[2], precision: 7);
Assert.Equal(expectedValues[index++], row.Change[3], precision: 7);
}
}
}
public void ChangeDetection()
{
using (var env = new ConsoleEnvironment(conc: 1))
{
const int size = 10;
List <Data> data = new List <Data>(size);
var dataView = env.CreateStreamingDataView(data);
List <Data> tempData = new List <Data>();
for (int i = 0; i < size / 2; i++)
{
tempData.Add(new Data(5));
}
for (int i = 0; i < size / 2; i++)
{
tempData.Add(new Data((float)(5 + i * 1.1)));
}
foreach (var d in tempData)
{
data.Add(new Data(d.Value));
}
var args = new IidChangePointDetector.Arguments()
{
Confidence = 80,
Source = "Value",
Name = "Change",
ChangeHistoryLength = size
};
// Train
var detector = new IidChangePointEstimator(env, args).Fit(dataView);
// Transform
var output = detector.Transform(dataView);
// Get predictions
var enumerator = output.AsEnumerable <Prediction>(env, true).GetEnumerator();
Prediction 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.Change[0]);
Assert.Equal(expectedValues[index++], row.Change[1]);
Assert.Equal(expectedValues[index++], row.Change[2]);
Assert.Equal(expectedValues[index++], row.Change[3]);
}
}
}
private void GenericDenseDataView <T>(T[] v1, T[] v2)
{
var inputs = new[] {
new DenseExample <T>()
{
X = v1
},
new DenseExample <T>()
{
X = v2
}
};
using (var host = new ConsoleEnvironment())
{
var data = host.CreateStreamingDataView(inputs);
var value = new VBuffer <T>();
int n = 0;
using (var cur = data.GetRowCursor(i => true))
{
var getter = cur.GetGetter <VBuffer <T> >(0);
while (cur.MoveNext())
{
getter(ref value);
Assert.True(value.GetValues().Length == 3);
++n;
}
}
Assert.True(n == 2);
var iter = data.AsEnumerable <DenseExample <T> >(host, false).GetEnumerator();
n = 0;
while (iter.MoveNext())
{
++n;
}
Assert.True(n == 2);
}
}
private void GenericSparseDataView <T>(T[] v1, T[] v2)
{
var inputs = new[] {
new SparseExample <T>()
{
X = new VBuffer <T> (5, 3, v1, new int[] { 0, 2, 4 })
},
new SparseExample <T>()
{
X = new VBuffer <T> (5, 3, v2, new int[] { 0, 1, 3 })
}
};
using (var host = new ConsoleEnvironment())
{
var data = host.CreateStreamingDataView(inputs);
var value = new VBuffer <T>();
int n = 0;
using (var cur = data.GetRowCursor(i => true))
{
var getter = cur.GetGetter <VBuffer <T> >(0);
while (cur.MoveNext())
{
getter(ref value);
Assert.True(value.Count == 3);
++n;
}
}
Assert.True(n == 2);
var iter = data.AsEnumerable <SparseExample <T> >(host, false).GetEnumerator();
n = 0;
while (iter.MoveNext())
{
++n;
}
Assert.True(n == 2);
}
}
/// <summary>
/// Runs a simple test.
/// </summary>
public static void TestScikitAPI()
{
var inputs = new[] {
new ExampleVector()
{
X = new float[] { 1, 10, 100 }
},
new ExampleVector()
{
X = new float[] { 2, 3, 5 }
},
new ExampleVector()
{
X = new float[] { 2, 4, 5 }
},
new ExampleVector()
{
X = new float[] { 2, 4, 7 }
},
};
var inputs2 = new[] {
new ExampleVector()
{
X = new float[] { -1, -10, -100 }
},
new ExampleVector()
{
X = new float[] { -2, -3, -5 }
},
new ExampleVector()
{
X = new float[] { 3, 4, 5 }
},
new ExampleVector()
{
X = new float[] { 3, 4, 7 }
},
};
using (var host = new ConsoleEnvironment(conc: 1))
{
ComponentHelper.AddStandardComponents(host);
var data = host.CreateStreamingDataView(inputs);
using (var pipe = new ScikitPipeline(new[] { "poly{col=X}" }, "km{k=2}", host))
{
var predictor = pipe.Train(data, feature: "X");
if (predictor == null)
{
throw new Exception("Test failed: no predictor.");
}
var data2 = host.CreateStreamingDataView(inputs2);
var predictions = pipe.Predict(data2);
var df = DataFrameIO.ReadView(predictions);
if (df.Shape.Item1 != 4 || df.Shape.Item2 != 12)
{
throw new Exception("Test failed: prediction failed.");
}
var dfs = df.ToString();
var dfs2 = dfs.Replace("\n", ";");
if (!dfs2.StartsWith("X.0,X.1,X.2,X.3,X.4,X.5,X.6,X.7,X.8,PredictedLabel,Score.0,Score.1;-1,-10,-100,1,10,100,100,1000,10000"))
{
throw new Exception("Test failed: prediction failed (header).");
}
}
}
}