/// <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; }