public void RunPipelineTest() { // Creates learning api object LearningApi api = new LearningApi(TestHelpers.GetDescriptor()); // Initialize data provider api.UseCsvDataProvider(m_iris_data_path, ',', 1); // Use mapper for data, which will extract (map) required columns api.UseDefaultDataMapper(); // Use MinMax data normalizer //api.UseMinMaxNormalizer(m_stats.Select(x => x.Min).ToArray(), m_stats.Select(x => x.Max).ToArray()); // We could also use some other normalizer like Gaus data normalizer //api.UseGaussNormalizer(m_stats.Select(x => x.Mean).ToArray(), m_stats.Select(x => x.StDev).ToArray()); // Prepares the ML Algoritm and setup parameters api.UseBackPropagation(1, 0.2, 1.0, null); //start process of learning api.Run(); // api.Train(); // api.TrainSample(); IScore status = api.GetScore(); //api.Train(vector) return; }
public bool InitNeuralBackPropagationTest() { // InitIrisMapperInJsonFormat_helper(); // Creates learning api object LearningApi api = new LearningApi(TestHelpers.GetDescriptor()); // Initialize data provider api.UseCsvDataProvider(m_IrisDataPath, ',', false, 1); // Use mapper for data, which will extract (map) required columns api.UseDefaultDataMapper(); // Use MinMax data normalizer //api.UseMinMaxNormalizer(); // We could also use some other normalizer like Gaus data normalizer //api.UseGaussNormalizer(m_stats.Select(x => x.Mean).ToArray(), m_stats.Select(x => x.StDev).ToArray()); // Prepares the ML Algoritm and setup parameters api.UseBackPropagation(1, 0.2, 1.0, null); api.Run(); IScore status = api.GetScore(); //api.Train(vector) return(true); }
public void MinMaxNormalization_test1() { // Creates learning api object LearningApi api = new LearningApi(loadMetaData1()); //Real dataset must be defined as object type, because data can be numeric, binary and classification api.UseActionModule <object[][], object[][]>((input, ctx) => { return(GetRealDataSample()); }); //this call must be first in the pipeline api.UseDefaultDataMapper(); // api.UseMinMaxNormalizer(); // var result = api.Run() as double [][]; //Test result for normalization var expected = GetNormalizedDataSample(); for (int i = 0; i < expected.Length; i++) { for (int j = 0; j < expected[0].Length; j++) { Assert.Equal(Math.Round(result[i][j], 5), expected[i][j]); } } // return; }
public void TestWithNormalize_MinMax() { // Creates learning api object LearningApi api = new LearningApi(loadMetaData1()); //Real dataset must be defined as object type, because data can be numeric, binary and classification api.UseActionModule <object[][], object[][]>((input, ctx) => { return(getRealDataSample(@"C:\Data\First.csv")); }); //this call must be first in the pipeline api.UseDefaultDataMapper(); // api.UseMinMaxNormalizer(); ////use denormalizer on normalized data //api.UseMinMaxDeNormalizer(); // var result = api.Run() as double[][]; Helpers.WriteToCSVFile(result); }
public void RBMDataSample1Test() { var dataPath = System.IO.Path.Combine(Directory.GetCurrentDirectory(), @"RestrictedBolzmannMachine2\Data\rbm_sample1.csv"); LearningApi api = new LearningApi(this.getDescriptorForRbm_sample1()); // Initialize data provider api.UseCsvDataProvider(dataPath, ',', false, 1); api.UseDefaultDataMapper(); api.UseRbm(0.2, 1000, 6, 3); RbmResult score = api.Run() as RbmResult; double[][] testData = new double[4][]; testData[0] = new double[] { 1, 1, 0, 0, 0, 0 }; testData[1] = new double[] { 0, 0, 0, 0, 1, 1 }; testData[2] = new double[] { 0, 1, 0, 0, 0, 0 }; testData[3] = new double[] { 0, 0, 0, 0, 1, 1 }; var result = api.Algorithm.Predict(testData, api.Context); // NOT FINISHED. //Assert.True(result[0] == 1); //Assert.True(result[1] == 0); //Assert.True(result[2] == 0); //Assert.True(result[3] == 0); //Assert.True(result[4] == 1); //Assert.True(result[5] == 0); }
public void Feature_and_LabelIndex_Mapping_Test2() { var desc = loadMetaData_with_CategoricFeature(); // Creates learning api object LearningApi api = new LearningApi(desc); //Real dataset must be defined as object type, because data can be numeric, binary and classification api.UseActionModule <object[][], object[][]>((input, ctx) => { return(loadRealDataSample()); }); //this call must be first in the pipeline api.UseDefaultDataMapper(); // var result = api.Run() as double[][]; var featureNumber = result[0].Count() - 1;//- labelcolumn //string column is not counted because it is ignored column //there is one category column in features so the number of features is increased with (calssCount-1) // featureCount = columnCount- strinCoulumnCount-LabelColumn + calssCount-1 var featureCount = 4 - 1 - 1 + (3 - 1); Assert.Equal(featureNumber, featureCount); }
public void LogisticRegression_Test_iterations_20_learningrate_015() { var desc = loadMetaData(); LearningApi api = new LearningApi(desc); //Real dataset must be defined as object type, because data can be numeric, binary and classification api.UseActionModule <object[][], object[][]>((input, ctx) => { return(loadRealDataSample()); }); // Use mapper for data, which will extract (map) required columns api.UseDefaultDataMapper(); api.UseMinMaxNormalizer(); //run logistic regression for 10 iteration with learningRate=0.15 api.UseLogisticRegression(0.15, 20); api.Run(); IScore score = api.GetScore(); //Errors during each iteration Assert.Equal(Math.Round(score.Errors[0], 5), 0.24236); Assert.Equal(Math.Round(score.Errors[1], 5), 0.23707); Assert.Equal(Math.Round(score.Errors[2], 5), 0.23358); Assert.Equal(Math.Round(score.Errors[3], 5), 0.23001); Assert.Equal(Math.Round(score.Errors[4], 5), 0.22806); Assert.Equal(Math.Round(score.Errors[5], 5), 0.22506); Assert.Equal(Math.Round(score.Errors[6], 5), 0.22409); Assert.Equal(Math.Round(score.Errors[7], 5), 0.22134); Assert.Equal(Math.Round(score.Errors[8], 5), 0.22105); Assert.Equal(Math.Round(score.Errors[9], 5), 0.21840); Assert.Equal(Math.Round(score.Errors[10], 5), 0.21857); Assert.Equal(Math.Round(score.Errors[11], 5), 0.21595); Assert.Equal(Math.Round(score.Errors[12], 5), 0.21640); Assert.Equal(Math.Round(score.Errors[13], 5), 0.21381); Assert.Equal(Math.Round(score.Errors[14], 5), 0.21439); Assert.Equal(Math.Round(score.Errors[15], 5), 0.21189); Assert.Equal(Math.Round(score.Errors[16], 5), 0.21251); Assert.Equal(Math.Round(score.Errors[17], 5), 0.21015); Assert.Equal(Math.Round(score.Errors[18], 5), 0.21076); Assert.Equal(Math.Round(score.Errors[19], 5), 0.20860); //LG Model Best Found model in 20 iteration Assert.Equal(Math.Round(score.Weights[0], 5), 0.28363); Assert.Equal(Math.Round(score.Weights[1], 5), 0.37424); Assert.Equal(Math.Round(score.Weights[2], 5), 1.41890); Assert.Equal(Math.Round(score.Weights[3], 5), 1.01207); Assert.Equal(Math.Round(score.Weights[4], 5), -0.33841); Assert.Equal(Math.Round(score.Weights[5], 5), -0.33841); Assert.Equal(Math.Round(score.Weights[6], 5), -1.62489); }
public void LogisticRegression_Test_Real_Example() { string m_binary_data_path = @"SampleData\binary\admit_binary.csv"; var binary_path = System.IO.Path.Combine(Directory.GetCurrentDirectory(), m_binary_data_path); LearningApi api = new LearningApi(loadMetaData1()); api.UseCsvDataProvider(binary_path, ',', false, 1); // Use mapper for data, which will extract (map) required columns api.UseDefaultDataMapper(); api.UseMinMaxNormalizer(); //run logistic regression for 10 iteration with learningRate=0.15 api.UseLogisticRegression(0.00012, 200); var score = api.Run(); ///**************PREDICTION AFTER MODEL IS CREATED*********//// /////define data for testing (prediction) LearningApi apiPrediction = new LearningApi(loadMetaData1()); //Real dataset must be defined as object type, because data can be numeric, binary and classification apiPrediction.UseActionModule <object[][], object[][]>((input, ctx) => { var data = new object[5][] { new object[] { 660, 3.88, 2, 1 }, new object[] { 580, 3.36, 2, 0 }, new object[] { 640, 3.17, 2, 0 }, new object[] { 640, 3.51, 2, 0 }, new object[] { 800, 3.05, 2, 1 }, }; return(data); }); // Use mapper for data, which will extract (map) required columns apiPrediction.UseDefaultDataMapper(); apiPrediction.UseMinMaxNormalizer(); var testData = apiPrediction.Run(); //use previous trained model var result = api.Algorithm.Predict(testData as double[][], api.Context) as LogisticRegressionResult; // Assert.Equal(Math.Round(result.PredictedValues[0], 0), 0); Assert.Equal(Math.Round(result.PredictedValues[1], 0), 0); Assert.Equal(Math.Round(result.PredictedValues[2], 0), 0); Assert.Equal(Math.Round(result.PredictedValues[3], 0), 0); Assert.Equal(Math.Round(result.PredictedValues[3], 0), 0); }
public void ContinuousTrainData() { double[][] initialCentroids = new double[4][]; initialCentroids[0] = new double[] { 0.2, -4.0 }; initialCentroids[1] = new double[] { 0.2, -6.0 }; initialCentroids[2] = new double[] { 0.4, -4.0 }; initialCentroids[3] = new double[] { 0.4, -6.0 }; string[] attributes = new string[] { "x", "y" }; int numAttributes = attributes.Length; // 2 in this demo (x,y) int numClusters = 4; int maxCount = 300; SaveLoadSettings sett; var resp = SaveLoadSettings.JSON_Settings(@"C:\Data\Function1.json", out sett, true); AnomalyDetectionAPI kmeanApi = new AnomalyDetectionAPI(null, numClusters); LearningApi api = new LearningApi(loadMetaData1()); api.UseActionModule <object[][], object[][]>((input, ctx) => { var rawDatalist = getRealDataSample(@"C:\Data\Function1.csv").ToList(); double[][] oldSamples; var nn = kmeanApi.GetPreviousSamples(sett, out oldSamples); if (oldSamples != null) { foreach (var old in oldSamples) { var row = old.Cast <object>().ToArray(); rawDatalist.Add(row); } } return(rawDatalist.ToArray()); }); //this call must be first in the pipeline api.UseDefaultDataMapper(); api.UseGaussNormalizer(); var rawData = api.Run() as double[][]; Helpers.WriteToCSVFile(rawData); ClusteringSettings Settings = new ClusteringSettings(rawData, maxCount, numClusters, numAttributes, sett, KmeansAlgorithm: 1, InitialGuess: true, Replace: true); AnomalyDetectionResponse response = kmeanApi.ImportNewDataForClustering(Settings); }
public void movieRecommendationTestCRbm(int iterations, double learningRate, int visNodes, int hidNodes) { Debug.WriteLine($"{iterations}-{visNodes}-{hidNodes}"); LearningApi api = new LearningApi(getDescriptorForRbm(3898)); // Initialize data provider api.UseCsvDataProvider(Path.Combine(Directory.GetCurrentDirectory(), @"RestrictedBolzmannMachine2\Data\movieDatasetTrain.csv"), ',', false, 0); api.UseDefaultDataMapper(); double[] featureVector = new double[] { 0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85 }; api.UseCRbm(featureVector, learningRate, iterations, visNodes, hidNodes); Stopwatch watch = new Stopwatch(); watch.Start(); RbmScore score = api.Run() as RbmScore; watch.Stop(); var hiddenNodes = score.HiddenValues; var hiddenWeight = score.HiddenBisases; double[] learnedFeatures = new double[hidNodes]; double[] hiddenWeights = new double[hidNodes]; for (int i = 0; i < hidNodes; i++) { learnedFeatures[i] = hiddenNodes[i]; hiddenWeights[i] = hiddenWeight[i]; } StreamWriter tw = new StreamWriter($"PredictedDigit_I{iterations}_V{visNodes}_H{hidNodes}_learnedbias.txt"); foreach (var item in score.HiddenBisases) { tw.WriteLine(item); } tw.Close(); var testData = ReadData(Path.Combine(Directory.GetCurrentDirectory(), @"RestrictedBolzmannMachine2\Data\movieDatasetTest.csv")); var result = api.Algorithm.Predict(testData, api.Context); var predictedData = ((RbmResult)result).VisibleNodesPredictions; var predictedHiddenNodes = ((RbmResult)result).HiddenNodesPredictions; var acc = testData.GetHammingDistance(predictedData); WriteDeepResult(iterations, new int[] { visNodes, hidNodes }, learningRate, acc, watch.ElapsedMilliseconds * 1000, predictedHiddenNodes); WriteOutputMatrix(iterations, new int[] { visNodes, hidNodes }, learningRate, predictedData, testData); }
public void Training() { int cnt = 0; double[][] initialCentroids = new double[4][]; initialCentroids[0] = new double[] { 0.4, 25.0 }; initialCentroids[1] = new double[] { 0.4, 15.0 }; initialCentroids[2] = new double[] { 0.6, 15.0 }; initialCentroids[3] = new double[] { 0.6, 25.0 }; string[] attributes = new string[] { "x", "y" }; int numAttributes = attributes.Length; int numClusters = 4; int maxCount = 300; ClusteringSettings clusterSettings = new ClusteringSettings(maxCount, numClusters, numAttributes, KmeansAlgorithm: 1, Replace: true); AnomalyDetectionAPI kmeanApi = new AnomalyDetectionAPI(clusterSettings); //AnomalyDetectionAPI(clusterSettings), Constractor should not be null when run Training() AnomalyDetectionResponse response; // Creates learning api object LearningApi api = new LearningApi(loadMetaData1()); api.UseActionModule <object[][], object[][]>((input, ctx) => { var rawDataArray = getData(cnt); return(rawDataArray); }); api.UseDefaultDataMapper(); api.UseGaussNormalizer(); // for (int i = 0; i < 15; i++) { cnt = i; var rawData = api.Run() as double[][]; response = kmeanApi.Training(rawData, initialCentroids); Helpers.WriteToCSVFile(kmeanApi.GetCentroid(), $"Data\\Centroid{i}.csv"); //response = kmeanApi.Save($"Function{i}.json"); } }
public void smileyTestCRbm(int iterations, double learningRate, int visNodes, int hidNodes) { LearningApi api = new LearningApi(getDescriptorForRbm(1600)); // Initialize data provider api.UseCsvDataProvider(Path.Combine(Directory.GetCurrentDirectory(), @"RestrictedBolzmannMachine2\Data\Smiley.csv"), ',', false, 0); api.UseDefaultDataMapper(); double[] featureVector = new double[] { 0.1, 0.2 }; api.UseCRbm(featureVector, learningRate, iterations, visNodes, hidNodes); Stopwatch watch = new Stopwatch(); watch.Start(); RbmScore score = api.Run() as RbmScore; watch.Stop(); var hiddenNodes = score.HiddenValues; var hiddenWeight = score.HiddenBisases; double[] learnedFeatures = new double[hidNodes]; double[] hiddenWeights = new double[hidNodes]; for (int i = 0; i < hidNodes; i++) { learnedFeatures[i] = hiddenNodes[i]; hiddenWeights[i] = hiddenWeight[i]; } var testData = ReadData(Path.Combine(Directory.GetCurrentDirectory(), @"RestrictedBolzmannMachine2\Data\SmileyTest.csv")); var result = api.Algorithm.Predict(testData, api.Context); var predictedData = ((RbmResult)result).VisibleNodesPredictions; var predictedHiddenNodes = ((RbmResult)result).HiddenNodesPredictions; var acc = testData.GetHammingDistance(predictedData); var ValTest = calcDelta(predictedData, testData); var lossTest = ValTest / (visNodes); Debug.WriteLine($"lossTest: {lossTest}"); WriteDeepResult(iterations, new int[] { visNodes, hidNodes }, acc, watch.ElapsedMilliseconds * 1000, predictedHiddenNodes); WriteOutputMatrix(iterations, new int[] { visNodes, hidNodes }, predictedData, testData); }
public void ContinuousTrainData2() { int cnt = 0; double[][] initialCentroids = new double[4][]; initialCentroids[0] = new double[] { 40.0, 10.0 }; initialCentroids[1] = new double[] { 20.0, 10.0 }; initialCentroids[2] = new double[] { 40.0, 20.0 }; initialCentroids[3] = new double[] { 20.0, 20.0 }; string[] attributes = new string[] { "x", "y" }; int numAttributes = attributes.Length; // 2 in this demo (x,y) int numClusters = 4; int maxCount = 300; SaveLoadSettings sett; var resp = SaveLoadSettings.JSON_Settings(@"C:\Data\Function1.json", out sett, true); AnomalyDetectionAPI kmeanApi = new AnomalyDetectionAPI(null, numClusters, initialCentroids); LearningApi api = new LearningApi(loadMetaData1()); api.UseActionModule <object[][], object[][]>((input, ctx) => { var rawDatalist = getData(cnt); return(rawDatalist); }); //this call must be first in the pipeline api.UseDefaultDataMapper(); api.UseGaussNormalizer(); for (int i = 0; i < 15; i++) { cnt = i; var rawData = api.Run() as double[][]; ClusteringSettings Settings = new ClusteringSettings(rawData, maxCount, numClusters, numAttributes, sett, KmeansAlgorithm: 1, InitialGuess: true, Replace: true); AnomalyDetectionResponse response = kmeanApi.ImportNewDataForClustering(Settings); } }
public void CRbm_ClassifierTest() { var dataPath = System.IO.Path.Combine(Directory.GetCurrentDirectory(), @"RestrictedBolzmannMachine2\Data\rbm_twoclass_sample.csv"); LearningApi api = new LearningApi(this.getDescriptorForRbmTwoClassesClassifier()); // Initialize data provider api.UseCsvDataProvider(dataPath, ';', false, 1); api.UseDefaultDataMapper(); double[] featureVector = new double[] { 0.1, 0.2, 0.3 }; api.UseCRbm(featureVector, 0.01, 1000, 10, 2); RbmResult score = api.Run() as RbmResult; double[][] testData = new double[5][]; // // This test data contains two patterns. One is grouped at left and one at almost right. testData[0] = new double[] { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 }; testData[1] = new double[] { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0 }; testData[2] = new double[] { 0, 0, 0, 0, 0, 1, 1, 1, 0, 0 }; testData[3] = new double[] { 0, 0, 0, 0, 0, 1, 0, 1, 0, 0 }; // This will be classified as third class. testData[4] = new double[] { 1, 1, 1, 0, 0, 1, 1, 1, 0, 0 }; var result = api.Algorithm.Predict(testData, api.Context) as RbmResult; // // 2 * BIT1 + BIT2 of [0] and [1] should be same. // We don't know how RBM will classiffy data. We only expect that // same or similar pattern of data will be assigned to the same class. // Note, we have here two classes (two hiddne nodes). // First and second data sample are of same class. Third and fourth are also of same class. // Here we check first classs. Assert.True(2 * result.HiddenNodesPredictions[0][0] + result.HiddenNodesPredictions[0][1] == 2 * result.HiddenNodesPredictions[1][0] + result.HiddenNodesPredictions[1][1]); // Here is test for second class. Assert.True(2 * result.HiddenNodesPredictions[2][0] + result.HiddenNodesPredictions[2][1] == 2 * result.HiddenNodesPredictions[3][0] + result.HiddenNodesPredictions[3][1]); printVector("Weights", result.Weights); }
public void LogisticsRegression_Test_iterations_10_learningrate_013() { var desc = loadMetaData(); LearningApi api = new LearningApi(desc); //Real dataset must be defined as object type, because data can be numeric, binary and classification api.UseActionModule <object[][], object[][]>((input, ctx) => { return(loadRealDataSample()); }); // Use mapper for data, which will extract (map) required columns api.UseDefaultDataMapper(); api.UseMinMaxNormalizer(); //run logistic regression for 10 iterations with learningRate=0.13 api.UseLogisticRegression(0.13, 10); api.Run(); IScore score = api.GetScore(); //Errors during each iteration. IF the learningRate is suitable erros is descrising for every next iteration Assert.Equal(Math.Round(score.Errors[0], 5), 0.24278); Assert.Equal(Math.Round(score.Errors[1], 5), 0.23749); Assert.Equal(Math.Round(score.Errors[2], 5), 0.23359); Assert.Equal(Math.Round(score.Errors[3], 5), 0.23010); Assert.Equal(Math.Round(score.Errors[4], 5), 0.22740); Assert.Equal(Math.Round(score.Errors[5], 5), 0.22476); Assert.Equal(Math.Round(score.Errors[6], 5), 0.22271); Assert.Equal(Math.Round(score.Errors[7], 5), 0.22065); Assert.Equal(Math.Round(score.Errors[8], 5), 0.21902); Assert.Equal(Math.Round(score.Errors[9], 5), 0.21739); //LG Model Best Found model in 10 iteration Assert.Equal(Math.Round(score.Weights[0], 5), 0.06494); Assert.Equal(Math.Round(score.Weights[1], 5), 0.21584); Assert.Equal(Math.Round(score.Weights[2], 5), 0.89901); Assert.Equal(Math.Round(score.Weights[3], 5), 0.51497); Assert.Equal(Math.Round(score.Weights[4], 5), -0.30213); Assert.Equal(Math.Round(score.Weights[5], 5), -0.30213); Assert.Equal(Math.Round(score.Weights[6], 5), -0.85624); }
public void DigitRecognitionDeepTest(int iterations, double learningRate, int[] layers) { Debug.WriteLine($"{iterations}-{String.Join("", layers)}"); LearningApi api = new LearningApi(getDescriptorForRbmTwoClassesClassifier(4096)); // Initialize data provider // TODO: Describe Digit Dataset. api.UseCsvDataProvider(Path.Combine(Directory.GetCurrentDirectory(), @"RestrictedBolzmannMachine2\Data\DigitDataset.csv"), ',', false, 0); api.UseDefaultDataMapper(); api.UseDeepRbm(learningRate, iterations, layers); Stopwatch watch = new Stopwatch(); watch.Start(); RbmDeepScore score = api.Run() as RbmDeepScore; watch.Stop(); var testData = RbmHandwrittenDigitUnitTests.ReadData(Path.Combine(Directory.GetCurrentDirectory(), @"RestrictedBolzmannMachine2\Data\predictiondigitdata.csv")); var result = api.Algorithm.Predict(testData, api.Context) as RbmDeepResult; var accList = new double[result.Results.Count]; var predictions = new double[result.Results.Count][]; var predictedHiddenNodes = new double[result.Results.Count][]; var Time = watch.ElapsedMilliseconds / 1000; int i = 0; foreach (var item in result.Results) { predictions[i] = item.First().VisibleNodesPredictions; predictedHiddenNodes[i] = item.Last().HiddenNodesPredictions; accList[i] = testData[i].GetHammingDistance(predictions[i]); i++; } RbmHandwrittenDigitUnitTests.WriteDeepResult(iterations, layers, accList, Time * 1000, predictedHiddenNodes); /// write predicted hidden nodes....... RbmHandwrittenDigitUnitTests.WriteOutputMatrix(iterations, layers, predictions, testData); }
public void smileyTestDeepRbm(int iterations, double learningRate, int[] layers) { LearningApi api = new LearningApi(getDescriptorForRbm(1600)); // Initialize data provider api.UseCsvDataProvider(Path.Combine(Directory.GetCurrentDirectory(), @"RestrictedBolzmannMachine2\Data\Smiley.csv"), ',', false, 0); api.UseDefaultDataMapper(); api.UseDeepRbm(learningRate, iterations, layers); Stopwatch watch = new Stopwatch(); watch.Start(); RbmDeepScore score = api.Run() as RbmDeepScore; watch.Stop(); var testData = ReadData(Path.Combine(Directory.GetCurrentDirectory(), @"RestrictedBolzmannMachine2\Data\SmileyTest.csv")); var result = api.Algorithm.Predict(testData, api.Context) as RbmDeepResult; var accList = new double[result.Results.Count]; var predictions = new double[result.Results.Count][]; var predictedHiddenNodes = new double[result.Results.Count][]; var Time = watch.ElapsedMilliseconds / 1000; int i = 0; foreach (var item in result.Results) { predictions[i] = item.First().VisibleNodesPredictions; predictedHiddenNodes[i] = item.Last().HiddenNodesPredictions; accList[i] = testData[i].GetHammingDistance(predictions[i]); i++; } var ValTest = calcDelta(predictions, testData); var lossTest = ValTest / (layers.First()); Debug.WriteLine($"lossTest: {lossTest}"); WriteDeepResult(iterations, layers, accList, Time / 60.0, predictedHiddenNodes); /// write predicted hidden nodes....... WriteOutputMatrix(iterations, layers, predictions, testData); }
public void Save_Test() { // Creates learning api object LearningApi api = new LearningApi(TestHelpers.GetDescriptor()); // Initialize data provider api.UseCsvDataProvider(m_IrisDataPath, ',', false, 1); // Use mapper for data, which will extract (map) required columns api.UseDefaultDataMapper(); // Prepares the ML Algorithm and setup parameters api.UseBackPropagation(1, 0.2, 1.0, null); api.Save("model1"); var loadedApi = LearningApi.Load("model1"); Assert.True(((BackPropagationNetwork)loadedApi.Algorithm).learningRate == ((BackPropagationNetwork)api.Algorithm).learningRate); }
public void TestWithNormalize_GaussAndCentroid() { double[][] initialCentroids = new double[4][]; initialCentroids[0] = new double[] { 0.2, -4.0 }; initialCentroids[1] = new double[] { 0.2, -6.0 }; initialCentroids[2] = new double[] { 0.4, -4.0 }; initialCentroids[3] = new double[] { 0.4, -6.0 }; string[] attributes = new string[] { "x", "y" }; // Creates learning api object LearningApi api = new LearningApi(loadMetaData1()); //Real dataset must be defined as object type, because data can be numeric, binary and classification api.UseActionModule <object[][], object[][]>((input, ctx) => { return(getRealDataSample(@"C:\Data\Function15.csv")); }); //this call must be first in the pipeline api.UseDefaultDataMapper(); api.UseGaussNormalizer(); var rawData = api.Run() as double[][]; int numAttributes = attributes.Length; // 2 in this demo (height,weight) int numClusters = 4; // vary this to experiment (must be between 2 and number data tuples) int maxCount = 300; // trial and error SaveLoadSettings sett; var resp = SaveLoadSettings.JSON_Settings(@"C:\Data\Function15.json", out sett, true); AnomalyDetectionAPI kmeanApi = new AnomalyDetectionAPI(rawData, numClusters); ClusteringSettings Settings = new ClusteringSettings(rawData, maxCount, numClusters, numAttributes, sett, KmeansAlgorithm: 1, InitialGuess: true, Replace: true); AnomalyDetectionResponse response = kmeanApi.ImportNewDataForClustering(Settings); }
public void Rbm_ClassifierTest2() { var dataPath = System.IO.Path.Combine(Directory.GetCurrentDirectory(), @"RestrictedBolzmannMachine2\Data\rbm_sample2.csv"); LearningApi api = new LearningApi(this.getDescriptorForRbmTwoClassesClassifier(21)); // Initialize data provider api.UseCsvDataProvider(dataPath, ',', false, 1); api.UseDefaultDataMapper(); api.UseDeepRbm(0.2, 10000, new int[] { 21, 9, 6, 2 }); RbmResult score = api.Run() as RbmResult; var expectedResults = new Dictionary <int, List <double[]> >(); // All test data, which belong to the sam class. List <double[]> testListClass1 = new List <double[]>(); List <double[]> testListClass2 = new List <double[]>(); // // This test data contains two patterns. One is grouped at left and one at almost right. // testListClass1 contains class 1 // testListClass2 contains class 2 testListClass1.Add(new double[] { 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }); testListClass1.Add(new double[] { 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }); testListClass1.Add(new double[] { 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }); testListClass2.Add(new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0 }); testListClass2.Add(new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0 }); testListClass2.Add(new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 }); expectedResults.Add(1, testListClass1); expectedResults.Add(2, testListClass2); validateClassificationResult(api, expectedResults); }
public void LogisticsRegression_Test_iterations_10_learningrate_013() { var desc = loadMetaData(); LearningApi api = new LearningApi(desc); //Real dataset must be defined as object type, because data can be numeric, binary and classification api.UseActionModule <object[][], object[][]>((input, ctx) => { return(loadRealDataSample()); }); // Use mapper for data, which will extract (map) required columns api.UseDefaultDataMapper(); api.UseMinMaxNormalizer(); //run logistic regression for 10 iterations with learningRate=0.13 api.UseLogisticRegression(0.13, 10); api.Run(); LogisticRegressionScore score = api.GetScore() as LogisticRegressionScore; //Errors during each iteration. IF the learningRate is suitable errors is describing for every next iteration Assert.Equal(Math.Round(score.Errors[0], 5), 0.24278); Assert.Equal(Math.Round(score.Errors[1], 5), 0.23749); Assert.Equal(Math.Round(score.Errors[2], 5), 0.23359); Assert.Equal(Math.Round(score.Errors[3], 5), 0.23010); Assert.Equal(Math.Round(score.Errors[4], 5), 0.22740); Assert.Equal(Math.Round(score.Errors[5], 5), 0.22476); Assert.Equal(Math.Round(score.Errors[6], 5), 0.22271); Assert.Equal(Math.Round(score.Errors[7], 5), 0.22065); Assert.Equal(Math.Round(score.Errors[8], 5), 0.21902); Assert.Equal(Math.Round(score.Errors[9], 5), 0.21739); //LG Model Best Found model in 10 iteration Assert.Equal(Math.Round(score.Weights[0], 5), 0.06494); Assert.Equal(Math.Round(score.Weights[1], 5), 0.21584); Assert.Equal(Math.Round(score.Weights[2], 5), 0.89901); Assert.Equal(Math.Round(score.Weights[3], 5), 0.51497); Assert.Equal(Math.Round(score.Weights[4], 5), -0.30213); Assert.Equal(Math.Round(score.Weights[5], 5), -0.30213); Assert.Equal(Math.Round(score.Weights[6], 5), -0.85624); //define data for testing (prediction) LearningApi apiPrediction = new LearningApi(desc); //Real dataset must be defined as object type, because data can be numeric, binary and classification apiPrediction.UseActionModule <object[][], object[][]>((input, ctx) => { var data = new object[4][] { new object[] { 0.202, "blue", "male", 13, "yes" }, new object[] { 0.447, "green", "female", 37, "no" }, new object[] { 0.120, "red", "male", "21", "yes" }, new object[] { 0.313, "green", "male", 22, "yes" }, }; return(data); }); // Use mapper for data, which will extract (map) required columns apiPrediction.UseDefaultDataMapper(); var testData = apiPrediction.Run(); //use previous trained model var result = api.Algorithm.Predict(testData as double[][], api.Context) as LogisticRegressionResult; Assert.Equal(Math.Round(result.PredictedValues[0], 5), 1E-05); Assert.Equal(Math.Round(result.PredictedValues[1], 5), 0); Assert.Equal(Math.Round(result.PredictedValues[2], 5), 0); Assert.Equal(Math.Round(result.PredictedValues[3], 5), 0); }
public void Rbm_ClassifierTest() { var dataPath = System.IO.Path.Combine(Directory.GetCurrentDirectory(), @"RestrictedBolzmannMachine2\Data\rbm_twoclass_sample.csv"); LearningApi api = new LearningApi(this.getDescriptorForRbmTwoClassesClassifier(10)); // Initialize data provider api.UseCsvDataProvider(dataPath, ';', false, 1); api.UseDefaultDataMapper(); api.UseDeepRbm(0.2, 1000, new int[] { 10, 2 }); RbmResult score = api.Run() as RbmResult; double[][] trainData = new double[6][]; // All test data, which belong to the sam class. List <double[]> testListClass1 = new List <double[]>(); List <double[]> testListClass2 = new List <double[]>(); // // This test data contains two patterns. One is grouped at left and one at almost right. trainData[0] = new double[] { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 }; testListClass1.Add(trainData[0]); trainData[1] = new double[] { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0 }; testListClass1.Add(trainData[1]); trainData[2] = new double[] { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 }; testListClass1.Add(trainData[2]); trainData[3] = new double[] { 0, 0, 0, 0, 0, 1, 1, 1, 0, 0 }; testListClass2.Add(trainData[3]); trainData[4] = new double[] { 0, 0, 0, 0, 0, 1, 0, 1, 0, 0 }; testListClass2.Add(trainData[4]); trainData[5] = new double[] { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0 }; testListClass2.Add(trainData[5]); // This will be classified as third class. //testData[4] = new double[] { 1, 1, 1, 0, 0, 1, 1, 1, 0, 0 }; RbmDeepResult result = api.Algorithm.Predict(trainData, api.Context) as RbmDeepResult; var expectedResults = new Dictionary <int, List <double[]> >(); expectedResults.Add(1, testListClass1); expectedResults.Add(2, testListClass2); validateClassificationResult(api, expectedResults); // // 2 * BIT1 + BIT2 of [0] and [1] should be same. // We don't know how RBM will classiffy data. We only expect that // same or similar pattern of data will be assigned to the same class. // Note, we have here two classes (two hiddne nodes). // First and second data sample are of the same class. // Third and fourth are also of same class. See data. //// Here we check first classs. //Assert.True(result.Results[0].ToArray()[0].HiddenNodesPredictions[0] == result.Results[1].ToArray()[0].HiddenNodesPredictions[0] && // result.Results[0].ToArray()[0].HiddenNodesPredictions[1] == result.Results[1].ToArray()[0].HiddenNodesPredictions[1]); //// Here is test for second class. //Assert.True(result.Results[2].ToArray()[0].HiddenNodesPredictions[0] == result.Results[3].ToArray()[0].HiddenNodesPredictions[0] && // result.Results[2].ToArray()[0].HiddenNodesPredictions[1] == result.Results[3].ToArray()[0].HiddenNodesPredictions[1]); }