/// <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>
/// 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);
}
/// <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 static LearningApi Useimageedge(this LearningApi a)
{
Lap alg = new Lap();
a.AddModule(alg, "Useimageedge");
return(a);
}
/// <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);
}
{ /// <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");
}
/// <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>
/// 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>
/// 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);
}
/// <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);
}
public void GaussianAndMean()
{
LearningApi lApi = new LearningApi();
lApi.UseActionModule <double[, , ], double[, , ]>((input, ctx) =>
{
Bitmap myBitmap = new Bitmap($"{appPath}/TestPicture/test.gif");
double[,,] data = new double[myBitmap.Width, myBitmap.Height, 3];
for (int x = 0; x < myBitmap.Width; x++)
{
for (int y = 0; y < myBitmap.Height; y++)
{
Color pixelColor = myBitmap.GetPixel(x, y);
data[x, y, 0] = pixelColor.R;
data[x, y, 1] = pixelColor.G;
data[x, y, 2] = pixelColor.B;
}
}
return(data);
});
lApi.AddModule(new GaussianFilter());
lApi.AddModule(new MeanFilter());
double[,,] result = lApi.Run() as double[, , ];
Assert.True(result != null);
Bitmap blurBitmap = new Bitmap(result.GetLength(0), result.GetLength(1));
for (int x = 0; x < result.GetLength(0); x++)
{
for (int y = 0; y < result.GetLength(1); y++)
{
Color pixelColor = Color.FromArgb((int)result[x, y, 0], (int)result[x, y, 1], (int)result[x, y, 2]);
blurBitmap.SetPixel(x, y, pixelColor);
}
}
SaveImage(blurBitmap, "GaussianAndMean.jpg");
}
/// <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.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 UseSurvivalAnalysis(this LearningApi api, int iterations)
{
var alg = new SurvivalAnalysis();
alg.Iterations = iterations;
api.AddModule(alg, "Logistic Regression");
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);
}
public static LearningApi UseDeepRbm(this LearningApi api,
double learningRate, int iterations, int[] layers,
IActivationFunction activationFnc = null)
{
var alg = new DeepRbm(layers, iterations, learningRate /*, bool writeLossToFile = false*/);
api.AddModule(alg, $"Rbm_{Guid.NewGuid()}");
return(api);
}
public static LearningApi UseRbm(this LearningApi api,
double learningRate, int iterations, int numVisible, int numHidden,
IActivationFunction activationFnc = null)
{
var alg = new Rbm(numVisible, numHidden, iterations, learningRate);
api.AddModule(alg, "Rbm");
return(api);
}
public static LearningApi UseCRbm(this LearningApi api, double[] featureVector,
double learningRate, int iterations, int numVisible, int numHidden,
IActivationFunction activationFnc = null)
{
var alg = new CRbm(featureVector, numVisible, numHidden, iterations, learningRate /*, bool writeLossToFile = false*/);
api.AddModule(alg, $"Rbm_{Guid.NewGuid()}");
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);
}
public static LearningApi UsePerceptron(this LearningApi api,
double learningRate, int iterations,
Func <double, double> activationFunction = null,
bool traceTotalError = false)
{
var alg = new PerceptronAlgorithm(0, learningRate, iterations, activationFunction, traceTotalError);
api.AddModule(alg, "PerceptronAlgorithm");
return(api);
}
/// <summary>
///
/// </summary>
/// <param name="api">Context <seealso cref"LearningFoundation.LearningApi"></param></param>
/// <param name="learningRate"></param>
/// <param name="iterations"></param>
/// <returns></returns>
public static LearningApi UseDeltaRuleLearning(this LearningApi api, double learningRate, int iterations)
{
//Invoking the class of the algorithm to use
var alg = new DeltaLearning(iterations);
//now we add this algorithm(new instance of the class) to the learning api
api.AddModule(alg, "Delta Learning");
//after adding the instance to the api, return the api
return(api);
}
public void TestMapWithLearningAPI()
{
List <string> labels = new List <string>();
var api = new LearningApi();
api.UseActionModule <List <double[]>, List <double[]> >((data, context) =>
{
List <double[]> patterns = new List <double[]>();
var dimensions = 3;
StreamReader reader = File.OpenText(path + "\\SelfOrganizingMap\\Food.csv");
///<Summary>Ignore first line.
reader.ReadLine();
while (!reader.EndOfStream)
{
string[] line = reader.ReadLine().Split(',');
labels.Add(line[0]);
double[] inputs = new double[dimensions];
for (int i = 0; i < dimensions; i++)
{
inputs[i] = double.Parse(line[i + 1]);
}
patterns.Add(inputs);
}
reader.Dispose();
return(patterns);
});
api.AddModule(new Map(3, 10, 0.000001));
var r = api.Run() as Neuron[];
for (int i = 0; i < r.Length; i++)
{
System.Diagnostics.Debug.WriteLine("{0},{1},{2}", labels[i], r[i].m_X, r[i].m_Y);
}
}
public void LaplacianUnitTest1()
{
Lap laplacian = new Lap();
LearningApi a = new LearningApi();
a.UseActionModule <double[, , ], double[, , ]>((input, ctx) =>
{
string baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
string path = Path.Combine(baseDirectory, "TestImages\\img2.jpg");
double[,,] data = Load(path);
return(data);
});
a.AddModule(laplacian);
double[,,] output = a.Run() as double[, , ];
Assert.IsNotNull(output);
string baseDirectory2 = AppDomain.CurrentDomain.BaseDirectory;
string outputPath = Path.Combine(baseDirectory2, "OutputImages\\img_Test.jpg");
Save(output, outputPath);
}
public static LearningApi UseLearningApiAlgorithm(this LearningApi api)
{
var alg = new LearningApiAlgorithm();
api.AddModule(alg, "LearningApiAlgorithm");
return api;
}
