/// <summary>
/// UseKMeans is an extansion that call KMeans through LearningAPI
/// </summary>
/// <param name="api">the LearningAPI object</param>
/// <param name="settings">the desired clustering settings</param>
/// <returns></returns>
public static LearningApi UseKMeans(this LearningApi api, ClusteringSettings settings, double[][] centroids = null, double[] maxDistance = null)
{
var alg = new KMeans(settings, centroids, maxDistance);
api.AddModule(alg, "Rbm");
return(api);
}
/// <summary>
/// UseKMeans is an extension that call KMeans through LearningAPI
/// </summary>
/// <param name="api">the LearningAPI object</param>
/// <param name="settings">the desired clustering settings</param>
/// <returns></returns>
public static LearningApi UseKMeans(this LearningApi api, ClusteringSettings settings, double[] maxDistance = null)
{
var alg = new KMeansAlgorithm(settings.Clone(), maxDistance);
api.AddModule(alg, "Rbm");
return(api);
}
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 static LearningApi Useimageedge(this LearningApi a)
{
Lap alg = new Lap();
a.AddModule(alg, "Useimageedge");
return(a);
}
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;
}
{ /// <summary>
/// Creating Object of SobelConvolutionFilter in this method and adding it to api.
/// </summary>
/// <param name="api">this is a api used to add module to learningApi. It is used as reference of LearningApi</param>
/// <returns>It return api of LearningaApi</returns>
public static LearningApi UseSobelConvolutionFilter(this LearningApi api)
{
SobelConvolutionFilter sobelconvo = new SobelConvolutionFilter();
api.AddModule(sobelconvo, "UseSobelConvolutionFilter");
return(api);
}
public void SobelFilterTestForGrayscaleConversionImage()
{
LearningApi api = new LearningApi();
api.UseActionModule <double[, , ], double[, , ]>((input, ctx) =>
{
string baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
string path = Path.Combine(baseDirectory, "TestInputimages\\TIM3.jpg"); //path to bin directory of project
Bitmap bitmap = new Bitmap(path);
double[,,] data = helper.ConvertBitmapToDouble(bitmap); // convert bitmap to double
return(data);
});
api.AddModule(new SobelConvolutionFilter());
double[,,] result = api.Run() as double[, , ];
Bitmap bitresult = helper.ConvertDoubleToBitmap(result);// convert double to bitmap
string baseDirectory2 = AppDomain.CurrentDomain.BaseDirectory;
string outpath = baseDirectory2 + "\\TestOutputImages\\";
if (!Directory.Exists(outpath))
{
Directory.CreateDirectory(outpath);
}
bitresult.Save(outpath + "Output3.jpg");
}
public void Test_FunctionRecognitionModuleSave(int MinNoiseForPrediction, int MaxNoiseForPrediction)
{
#region Train and Save
var batch = 100;
var funcData = FunctionGenerator.CreateFunction(500, 2, 2 * Math.PI / 100);
LearningApi api = new LearningApi();
api.UseActionModule <object, double[][]>((notUsed, ctx) =>
{
var similarFuncData = FunctionGenerator.CreateSimilarFromReferenceFunc(funcData.ToArray(), 7, 10);
double[][] formattedData = formatData(similarFuncData);
return(formattedData);
});
double[][] initCentroids = new double[4][];
initCentroids[0] = new double[] { 1.53, 0.63 };
initCentroids[1] = new double[] { 4.68, -0.63 };
initCentroids[2] = new double[] { 7.85, 0.62 };
initCentroids[3] = new double[] { 10.99, -0.64 };
ClusteringSettings settings = new ClusteringSettings(0, numClusters: 4, numDims: 2, KmeansAlgorithm: 2, initialCentroids: initCentroids, tolerance: 0)
{
KmeansMaxIterations = 1000
};
api.UseKMeansFunctionRecognitionModule(settings);
KMeansFunctionRecognitonScore res;
while (batch-- > 0)
{
res = api.RunBatch() as KMeansFunctionRecognitonScore;
}
api.Save("sinusmodel");
#endregion
#region Load And Predict
var api2 = LearningApi.Load("sinusmodel");
var noisedFunc = FunctionGenerator.CreateSimilarFromReferenceFunc(funcData.ToArray(), MinNoiseForPrediction, MaxNoiseForPrediction);
double[][] data = formatData(noisedFunc);
var predictionResult = api2.Algorithm.Predict(data, null) as KMeansFunctionRecognitionResult;
// TRUE positives
if (MaxNoiseForPrediction <= 10)
{
Assert.True(predictionResult.Loss == 1.0);
}
// TRUE negatives
else if (MaxNoiseForPrediction >= 25)
{
Assert.False(predictionResult.Loss == 1.0);
}
#endregion
}
/// <summary>
/// Extension methods of LearningAPI for using MinMax denormalizer
/// </summary>
/// <param name="api"></param>
/// <returns></returns>
public static LearningApi UseMinMaxDeNormalizer(this LearningApi api)
{
var minMaxDeNorm = new MinMaxDeNormalizer();
api.Modules.Add("Denormilizer", minMaxDeNorm);
return(api);
}
public void Test_Save()
{
double[][] clusterCenters = new double[3][];
clusterCenters[0] = new double[] { 5.0, 5.0 };
clusterCenters[1] = new double[] { 15.0, 15.0 };
clusterCenters[2] = new double[] { 30.0, 30.0 };
string[] attributes = new string[] { "Height", "Weight" };
int numAttributes = attributes.Length; // 2 in this demo (height,weight)
int numClusters = 3; // vary this to experiment (must be between 2 and number data tuples)
int maxCount = 300; // trial and error
ClusteringSettings settings = new ClusteringSettings(maxCount, numClusters, numAttributes, KmeansAlgorithm: 2);
// Creates learning api object
LearningApi api = new LearningApi(loadDescriptor());
// creates data
var rawData = Helpers.CreateSampleData(clusterCenters, 2, 10000, 0.5);
KMeansAlgorithm kMeans = new KMeansAlgorithm(settings);
// train
var response = kMeans.Run(rawData, api.Context);
string fileName = "Test01.json";
kMeans.Save(rootFolder + fileName);
}
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 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 OR_Test()
{
LearningApi api = new LearningApi();
api.UseActionModule <object, double[][]>((notUsed, ctx) =>
{
ctx.DataDescriptor = get2DDescriptor();
double[][] data = new double[4][];
data[0] = new double[] { 0, 0, 0, 0.0 };
data[1] = new double[] { 0, 1, 1, 0.0 };
data[2] = new double[] { 1, 0, 1, 0.0 };
data[3] = new double[] { 1, 1, 1, 0.0 };
return(data);
});
api.UseDeltaLearning(0.2, 1000);
IScore score = api.Run() as IScore;
double[][] testData = new double[3][];
testData[0] = new double[] { 0, 0, 0.0 };
testData[1] = new double[] { 1, 1, 0.0 };
testData[2] = new double[] { 0, 1, 0.0 };
var result = api.Algorithm.Predict(testData, api.Context) as DeltaLearningResult;
Assert.True(result.PredictedResults[0] == 0);
Assert.True(result.PredictedResults[1] == 1);
Assert.True(result.PredictedResults[2] == 1);
}
/// <summary>
/// Installs the KMeanFunctionRecognitionModule in the LearningApi pipeline.
/// </summary>
/// <param name="api"></param>
/// <param name="settings"></param>
/// <returns></returns>
public static LearningApi UseKMeansFunctionRecognitionModule(this LearningApi api, ClusteringSettings settings)
{
var alg = new KMeansFunctionRecognitionAlgorithm(settings);
api.AddModule(alg, "KMeanFunctionRecognitionModule");
return(api);
}
public void RBMBinaryDataCreation()
{
//size of image
int size = 40;
var context = getImgRecognitionDescriptor(size * size);
LearningApi api = new LearningApi(context);
api.UseActionModule <object, double[][]>((notUsed, ctx) =>
{
double[][] trainData = new double[22][];
for (int j = 0; j < 1; j++)
{
//Path of training images.
//return getImageData(size, $"{Directory.GetCurrentDirectory()}\\RestrictedBolzmannMachine2\\TrainingImages");
trainData = getImageData(size, imagePath + j);
}
return(trainData);
});
IScore score = api.Run() as IScore;
//DigitDatasetCSVFile.Close();
SmileyCSVFile.Close();
}
/// <summary>
/// Extension methods of LearningAPI for using Gauss denormalizer
/// </summary>
/// <param name="api"></param>
/// <returns></returns>
public static LearningApi UseGaussDeNormalizer(this LearningApi api)
{
var minMaxDeNorm = new GaussDeNormalizer();
api.AddModule(minMaxDeNorm, "GaussDenormilizer");
return(api);
}
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);
}
/// <summary>
/// perform the loading data from SCV file
/// </summary>
/// <param name="api">instance of the LearningAPI</param>
/// <param name="fileName">csv file path</param>
/// <param name="delimiter">csv delimiter</param>
/// <param name="isHeader"> is header included in the data after skiped rows. </param>
/// <param name="skipRows">firs several rows which should be skiped in parsing.</param>
/// <returns></returns>
public static LearningApi UseCsvDataProvider(this LearningApi api, string fileName, char delimiter, bool isHeader, int skipRows = 0)
{
var dp = new CsvDataProvider(fileName, delimiter, isHeader, skipRows);
api.AddModule(dp, "CsvDataProvider");
return(api);
}
/// <summary>
/// perform the loading data from SCV file
/// </summary>
/// <param name="api">instance of the LearningAPI</param>
/// <param name="strContent">csv string</param>
/// <param name="delimiter">csv delimiter</param>
/// <param name="isHeader"> is header included in the data after skiped rows. </param>
/// <param name="skipRows">firs several rows which should be skiped in parsing.</param>
/// <returns></returns>
public static LearningApi UseCsvDataParser(this LearningApi api, string strContent, char delimiter, bool isHeader, int skipRows = 0)
{
var dp = new CsvDataParser(strContent, delimiter, isHeader, skipRows);
api.AddModule(dp, "CsvDataParser");
return(api);
}
/// <summary>
/// Extension methods of LearningAPI for using MinMax normalizer
/// </summary>
/// <param name="api">LearningAPI</param>
/// <returns></returns>
public static LearningApi UseMinMaxNormalizer(this LearningApi api)
{
var minMaxNorm = new MinMaxNormalizer();
api.AddModule(minMaxNorm, "Normalizer");
return(api);
}
/// <summary>
/// Extension methods of LearningAPI for Gauss MinMax normalizer
/// </summary>
/// <param name="api">LearningAPI</param>
/// <returns></returns>
public static LearningApi UseGaussNormalizer(this LearningApi api)
{
var minMaxNorm = new GaussNormalizer();
api.Modules.Add("GaussNormilizer", minMaxNorm);
return(api);
}
/// <summary>
/// Loads and initializes data mapper
/// </summary>
/// <param name="api">LearningAPI </param>
/// <returns></returns>
public static LearningApi UseDefaultDataMapper(this LearningApi api)
{
var dm = new DataMapper();
api.Modules.Add("DataMapper", dm);
return(api);
}
/// <summary>
/// Loads and initializes data mapper
/// </summary>
/// <param name="api">LearningAPI </param>
/// <returns></returns>
public static LearningApi UseDefaultDataMapper(this LearningApi api)
{
var dm = new DataMapper();
api.AddModule(dm, "DataMapper");
return(api);
}
public void Test_LoadSave()
{
string moduleName = "test-action";
double[][] clusterCentars = new double[3][];
clusterCentars[0] = new double[] { 5.0, 5.0 };
clusterCentars[1] = new double[] { 15.0, 15.0 };
clusterCentars[2] = new double[] { 30.0, 30.0 };
string[] attributes = new string[] { "Height", "Weight" };
int numAttributes = attributes.Length; // 2 in this demo (height,weight)
int numClusters = 3; // vary this to experiment (must be between 2 and number data tuples)
int maxCount = 300; // trial and error
ClusteringSettings settings = new ClusteringSettings(maxCount, numClusters, numAttributes, KmeansAlgorithm: 1);
// Creates learning api object
LearningApi api = new LearningApi(loadDescriptor());
//
// Defines action method, which will generate training data.
api.UseActionModule <object, double[][]>((data, ctx) =>
{
var rawData = Helpers.CreateSampleData(clusterCentars, 2, 10000, 0.5);
return(rawData);
}, moduleName);
api.UseKMeans(settings);
var resp = api.Run() as KMeansScore;
Assert.True(resp.Model.Clusters != null);
Assert.True(resp.Model.Clusters.Length == clusterCentars.Length);
var result = api.Algorithm.Predict(clusterCentars, api.Context) as KMeansResult;
Assert.True(result.PredictedClusters[0] == 0);
Assert.True(result.PredictedClusters[1] == 1);
Assert.True(result.PredictedClusters[2] == 2);
// This is where trained model is saved.
api.Save(nameof(TestLoadSave));
// Loads the saved model.
var loadedApi = LearningApi.Load(nameof(TestLoadSave));
//
// Because we have used action method in the LearningApi, we will have to setup it again.
// This is not required because API design limitation. It is restriction of .NET framework. It cannot persist code.
loadedApi.ReplaceActionModule <object, double[][]>(moduleName, (data, ctx) =>
{
var rawData = Helpers.CreateSampleData(clusterCentars, 2, 10000, 0.5);
return(rawData);
});
loadedApi.Run();
}
public void calculateCorrelation_test1()
{
//
LearningApi api = new LearningApi(null);
// Initialize data provider
api.UseCsvDataProvider(@"CorrelationMatrix/corellation_data.csv", ',', true, 0);
//Custom action of dataset
api.UseActionModule <object[][], double[][]>((input, ctx) =>
{
return(toColumnVector(input));
});
// api.UseMinMaxNormalizer();
var data = api.Run() as double[][];
var prov = api.GetModule <CsvDataProvider>("CsvDataProvider");
var strData = new List <string>();
var hed = prov.Header.ToList();
hed.Insert(0, "");
strData.Add(string.Join(",", hed.ToArray()));
for (int i = 0; i < data.Length; i++)
{
var lst = new List <string>();
lst.Add(prov.Header[i]);
for (int k = 0; k < i; k++)
{
lst.Add(" ");
}
for (int j = i; j < data.Length; j++)
{
var corValue = data[i].CorrCoeffOf(data[j]);
if (double.IsNaN(corValue))
{
continue;
}
lst.Add(corValue.ToString("n5", CultureInfo.InvariantCulture));
}
strData.Add(string.Join(",", lst));
}
Assert.True("Col1,1.00000,0.16892,0.99111,0.75077,-0.82354,-0.85164" == strData[1]);
System.IO.File.WriteAllLines(@"CorrelationMatrix/strCorrlation.txt", strData);
//
return;
}
/// <summary>
/// The implementation of Logistics Regression machine learning algorithm
/// </summary>
/// <param name="api"></param>
/// <param name="learningRate"></param>
/// <returns></returns>
public static LearningApi UseSurvivalAnalysis(this LearningApi api, int iterations)
{
var alg = new SurvivalAnalysis();
alg.Iterations = iterations;
api.AddModule(alg, "Logistic Regression");
return(api);
}
/// <summary>
/// The implementation of Logistics Regression machine learning algorithm
/// </summary>
/// <param name="api"></param>
/// <param name="learningRate"></param>
/// <returns></returns>
public static LearningApi UseLogisticRegression(this LearningApi api, double learningRate, int iterations)
{
var alg = new LogisticRegression(learningRate);
alg.Iterations = iterations;
api.Modules.Add("Logistic Regression", alg);
return(api);
}
public static LearningApi UseBackPropagation(this LearningApi api,
int hiddenLayerCount, double momentum, double learningRate,
IActivationFunction activationFnc)
{
var alg = new BackPropagationNetwork(hiddenLayerCount, momentum, learningRate, activationFnc);
api.AddModule(alg, "Algorithm");
return(api);
}
/// <summary>
/// This method is invoked from the unit test project to train the neural network on the training data
/// </summary>
/// <param name="api">Learning api</param>
/// <param name="learningRate">learning rate of the network</param>
/// <param name="iterations">Number of epochs</param>
/// <param name="hiddenlayerneurons">Defines list of layers with number of hidden layer neurons at every layer.</param>
/// <param name="activationFnc">activation function</param>
/// <returns>LearningApi</returns>
public static LearningApi UseMLPerceptron(this LearningApi api,
double learningRate, int iterations, int batchSize, int testCaseNumber, int[] hiddenlayerneurons = null,
IActivationFunction activationFnc = null)
{
var alg = new MLPerceptronAlgorithm(learningRate, iterations, batchSize, testCaseNumber, hiddenlayerneurons);
api.AddModule(alg, "MLPerceptronAlgorithm");
return(api);
}
