public override Task TrainAsync(ClassificationModel classificationModel)
{
int numFeatures = classificationModel.FeatureVectors.Count;
double[][] input = new double[numFeatures][];
int[] responses = new int[numFeatures];
for (int featureIndex = 0;
featureIndex < classificationModel.FeatureVectors.Count;
++featureIndex)
{
var featureVector = classificationModel.FeatureVectors[featureIndex];
input[featureIndex] = Array.ConvertAll(featureVector.FeatureVector.BandIntensities, s => (double)s / ushort.MaxValue);
responses[featureIndex] = (int)featureVector.FeatureClass;
}
NaiveBayesLearning <NormalDistribution> learning = new NaiveBayesLearning <NormalDistribution>();
return(Task.Factory.StartNew(() =>
{
learning.Options.InnerOption = new NormalOptions()
{
Regularization = 1e-5
};
_bayes = learning.Learn(input, responses);
}));
}
private static void naiveBayes(double[][] inputs, int[] outputs)
{
// Create a new Naive-Bayes teaching algorithm with normal distributions.
// Note: the generic parameters are optional, but they help increasing the
// type safety of the teacher. For example, by specifying the NormalOptions
// argument, we will be able to configure settings that are very specific
// to normal distributions in the NaiveBayes teacher:
var teacher = new NaiveBayesLearning <NormalDistribution, NormalOptions>()
{
Empirical = true // Estimate class priors from the data
};
// As mentioned above, because we specified the NormalOptions generic
// parameter, now we can configure settings such as Gaussian regularization,
// robustness and constraints (note: setting those is completely optional).
teacher.Options.InnerOption.Regularization = 1e-10;
teacher.Options.InnerOption.Diagonal = false;
// Learn the Naive Bayes classifier
var nb = teacher.Learn(inputs, outputs);
// Get predictions according to kNN
int[] predicted = nb.Decide(inputs);
// Create a confusion matrix to check the quality of the predictions:
var cm = new ConfusionMatrix(predicted: predicted, expected: outputs);
// Check the accuracy measure:
double accuracy = cm.Accuracy; // (should be 1.0 or 100%)
}
public void nativeBayesValidation()
{
var learn = new NaiveBayesLearning();
NaiveBayes nb = learn.Learn(inputsInt, outputs);
var cv = CrossValidation.Create(
k: 3,
learner: (p) => new NaiveBayesLearning(),
loss: (actual, expected, p) => new ZeroOneLoss(expected).Loss(actual),
fit: (teacher, x, y, w) => teacher.Learn(x, y, w),
x: inputsInt, y: outputs
);
var result = cv.Learn(inputsInt, outputs);
int numberOfSamples = result.NumberOfSamples;
int numberOfInputs = result.NumberOfInputs;
int numberOfOutputs = result.NumberOfOutputs;
double trainingError = result.Training.Mean;
double validationError = result.Validation.Mean;
GeneralConfusionMatrix gcm = result.ToConfusionMatrix(inputsInt, outputs);
double accuracy = gcm.Accuracy;
message += "Native Bayes Validacja\n";
message += "trainingError " + trainingError.ToString() + "\n";
message += "validationError " + validationError.ToString() + "\n";
message += "accuracy " + accuracy.ToString() + "\n\n";
}
public void gh1056()
{
string basePath = NUnit.Framework.TestContext.CurrentContext.WorkDirectory;
string worksheetPath = Path.Combine(basePath, "Resources", "examples.xls");
// https://github.com/accord-net/framework/issues/1056
DataTable table = new ExcelReader(worksheetPath).GetWorksheet("Classification - Yin Yang");
double[][] inputs = table.ToJagged <double>("X", "Y");
int[] outputs = Classes.ToZeroOne(table.Columns["G"].ToArray <int>());
var teacher = new NaiveBayesLearning <NormalDistribution>();
var nb = teacher.Learn(inputs, outputs);
int numberOfClasses = nb.NumberOfClasses;
int numberOfInputs = nb.NumberOfInputs;
int[] answers = nb.Decide(inputs);
var cm = ConfusionMatrix.Estimate(nb, inputs, outputs);
double acc = cm.Accuracy;
Assert.AreEqual(0.859999, cm.Accuracy, 1e-4);
Assert.AreEqual(2, numberOfClasses);
Assert.AreEqual(2, numberOfInputs);
}
private void Train(IEnumerable <RestaurantReview> trainingDataset)
{
// Our independant variable of the review text
string[] inputs = trainingDataset.Select(x => x.Review).ToArray();
// Our dependant variable is whether or not the review is positive
int[] outputs = trainingDataset.Select(x => Convert.ToInt32(x.IsPositive)).ToArray();
// Clean review text
inputs = inputs.Select(this.CleanReview).ToArray();
// Convert the reviews into a multidimensial array. Each review will contain the words of of the review
// Also removes any punctation and other marks
string[][] wordsPerReview = inputs.Tokenize();
// Use the bag of words model to creates a sparse matrix that will say wether or not a review contains a certain word
// All words will be added a column
this._bagOfWordsModel = new BagOfWords();
this._bagOfWordsModel.Learn(wordsPerReview);
double[][] bagOfWordsResult = this._bagOfWordsModel.Transform(wordsPerReview);
// Use the naive bayes algorithm for our text classification.
NaiveBayesLearning <NormalDistribution> naiveBayesTeacher = new NaiveBayesLearning <NormalDistribution>();
naiveBayesTeacher.Options.InnerOption = new NormalOptions()
{
Regularization = 1e-5 // to avoid zero variances exceptions
};
this._naiveBayesModel = naiveBayesTeacher.Learn(bagOfWordsResult, outputs);
}
public void gh_758()
{
// Let's say we have the following data to be classified into three
// non -mutually-exclusive possible classes. Those are the samples:
//
int[][] inputs =
{
// input output
new int[] { 0, 1, 1, 0 }, // 0
new int[] { 0, 1, 0, 0 }, // 0
new int[] { 0, 0, 1, 0 }, // 0
new int[] { 0, 1, 1, 0 }, // 0, 1
new int[] { 0, 1, 0, 0 }, // 0, 1
new int[] { 1, 0, 0, 0 }, // 1
new int[] { 1, 0, 0, 0 }, // 1
new int[] { 1, 0, 0, 1 }, // 1, 2
new int[] { 0, 0, 0, 1 }, // 1, 2
new int[] { 0, 0, 0, 1 }, // 1, 2
new int[] { 1, 1, 1, 1 }, // 2
new int[] { 1, 0, 1, 1 }, // 2
new int[] { 1, 1, 0, 1 }, // 2
new int[] { 0, 1, 1, 1 }, // 2
new int[] { 1, 1, 1, 1 }, // 2
};
int[][] outputs = // those are the class labels
{
new[] { 1, 0, 0 },
new[] { 1, 0, 0 },
new[] { 1, 0, 0 },
new[] { 1, 1, 0 },
new[] { 1, 1, 0 },
new[] { 0, 1, 0 },
new[] { 0, 1, 0 },
new[] { 0, 1, 1 },
new[] { 0, 1, 1 },
new[] { 0, 1, 1 },
new[] { 0, 0, 1 },
new[] { 0, 0, 1 },
new[] { 0, 0, 1 },
new[] { 0, 0, 1 },
new[] { 0, 0, 1 },
};
// Create a new Naive Bayes teacher
var teacher = new NaiveBayesLearning();
teacher.ParallelOptions.MaxDegreeOfParallelism = 1;
var bayes = teacher.Learn(inputs, outputs);
double[][] prediction = bayes.Probabilities(inputs);
// Teach the Naive Bayes model. The error should be zero:
double error = new BinaryCrossEntropyLoss(outputs).Loss(prediction);
Assert.AreEqual(11.566909963298386, error, 1e-8);
Assert.IsTrue(teacher.optimized);
}
public UsersClassificationService()
{
var learningSet = new List <Tuple <UserType, UserStatistics> >()
{
Tuple.Create(UserType.Average, new UserStatistics(3, 3, 1, 100.5)),
Tuple.Create(UserType.Average, new UserStatistics(2, 2, 1, 100.5)),
Tuple.Create(UserType.Average, new UserStatistics(3, 0, 4, 200.5)),
Tuple.Create(UserType.Average, new UserStatistics(3, 1, 3, 175.0)),
Tuple.Create(UserType.Average, new UserStatistics(1, 3, 1, 50.0)),
Tuple.Create(UserType.Average, new UserStatistics(0, 1, 3, 100.5)),
Tuple.Create(UserType.Good, new UserStatistics(4, 1, 7, 400.5)),
Tuple.Create(UserType.Good, new UserStatistics(2, 5, 7, 330.7)),
Tuple.Create(UserType.Good, new UserStatistics(5, 4, 6, 300.5)),
Tuple.Create(UserType.Good, new UserStatistics(6, 6, 6, 200.5)),
Tuple.Create(UserType.Good, new UserStatistics(4, 5, 6, 323.5)),
Tuple.Create(UserType.Good, new UserStatistics(6, 3, 3, 350.5)),
};
var learner = new NaiveBayesLearning <NormalDistribution>();
var inputs = learningSet.Select(x => x.Item2.ToArray()).ToArray();
var outputs = learningSet.Select(x => (int)x.Item1).ToArray();
_naiveBayes = learner.Learn(inputs, outputs);
}
private void DoBayesAnalyze()
{
Codification codebook = new Codification(specialValueColumnNames, data);
int[][] symbols = codebook.Transform(data);
int[][] inputs = symbols.Get(null, 0, -1);
int[] outputs = symbols.GetColumn(-1);
// Create a new Naive Bayes learning
var learner = new NaiveBayesLearning();
NaiveBayes nb = learner.Learn(inputs, outputs);
var currentSprint = App.GetReleaseScrumData().CurrentSprintProxy.CurrentSprint;
foreach (var story in currentSprint.Stories)
{
if (excludeOwners.Contains(story.Owner))
{
story.PredicateSuccessRate = noResultReasonExcludeUser;
continue;
}
if (story.Size <= 0)
{
story.PredicateSuccessRate = noResultReasonStorySize0;
continue;
}
int[] storyInstance = codebook.Transform(new string[] { story.Size.ToString(), story.Owner });
double[] probs = nb.Probabilities(storyInstance);
var sucessRate = probs[0] * 100;
var pSuccessRate = string.Format("{0:N2}", sucessRate);
story.PredicateSuccessRate = string.Format("{0}%", pSuccessRate);
}
}
private static void BuildNBModel(double[][] trainInput, int[] trainOutput, double[][] testInput, int[] testOutput)
{
var teacher = new NaiveBayesLearning <NormalDistribution>();
var nbModel = teacher.Learn(trainInput, trainOutput);
int[] inSamplePreds = nbModel.Decide(trainInput);
int[] outSamplePreds = nbModel.Decide(testInput);
// Accuracy
double inSampleAccuracy = 1 - new ZeroOneLoss(trainOutput).Loss(inSamplePreds);
double outSampleAccuracy = 1 - new ZeroOneLoss(testOutput).Loss(outSamplePreds);
Console.WriteLine("* In-Sample Accuracy: {0:0.0000}", inSampleAccuracy);
Console.WriteLine("* Out-of-Sample Accuracy: {0:0.0000}", outSampleAccuracy);
// Build confusion matrix
int[][] confMatrix = BuildConfusionMatrix(
testOutput, outSamplePreds, 10
);
System.IO.File.WriteAllLines(
Path.Combine(
@"\\Mac\Home\Documents\c-sharp-machine-learning\ch.8\input-data",
"nb-conf-matrix.csv"
),
confMatrix.Select(x => String.Join(",", x))
);
// Precision Recall
PrintPrecisionRecall(confMatrix);
DrawROCCurve(testOutput, outSamplePreds, 10, "NB");
}
public void learn_test()
{
#region doc_learn
// Let's say we have the following data to be classified
// into three possible classes. Those are the samples:
//
double[][] inputs =
{
// input output
new double[] { 0, 1, 1, 0 }, // 0
new double[] { 0, 1, 0, 0 }, // 0
new double[] { 0, 0, 1, 0 }, // 0
new double[] { 0, 1, 1, 0 }, // 0
new double[] { 0, 1, 0, 0 }, // 0
new double[] { 1, 0, 0, 0 }, // 1
new double[] { 1, 0, 0, 0 }, // 1
new double[] { 1, 0, 0, 1 }, // 1
new double[] { 0, 0, 0, 1 }, // 1
new double[] { 0, 0, 0, 1 }, // 1
new double[] { 1, 1, 1, 1 }, // 2
new double[] { 1, 0, 1, 1 }, // 2
new double[] { 1, 1, 0, 1 }, // 2
new double[] { 0, 1, 1, 1 }, // 2
new double[] { 1, 1, 1, 1 }, // 2
};
int[] outputs = // those are the class labels
{
0, 0, 0, 0, 0,
1, 1, 1, 1, 1,
2, 2, 2, 2, 2,
};
// Create a new Gaussian distribution naive Bayes learner
var teacher = new NaiveBayesLearning <NormalDistribution>();
// Set options for the component distributions
teacher.Options.InnerOption = new NormalOptions
{
Regularization = 1e-5 // to avoid zero variances
};
// Learn the naive Bayes model
NaiveBayes <NormalDistribution> bayes = teacher.Learn(inputs, outputs);
// Use the model to predict class labels
int[] predicted = bayes.Decide(inputs);
// Estimate the model error. The error should be zero:
double error = new ZeroOneLoss(outputs).Loss(predicted);
// Now, let's test the model output for the first input sample:
int answer = bayes.Decide(new double[] { 1, 0, 0, 1 }); // should be 1
#endregion
Assert.AreEqual(0, error);
Assert.AreEqual(1, answer);
Assert.IsTrue(predicted.IsEqual(outputs));
}
public void learn_no_datatable()
{
#region doc_mitchell_no_datatable
string[] columnNames = { "Outlook", "Temperature", "Humidity", "Wind", "PlayTennis" };
string[][] data =
{
new string[] { "Sunny", "Hot", "High", "Weak", "No" },
new string[] { "Sunny", "Hot", "High", "Strong", "No" },
new string[] { "Overcast", "Hot", "High", "Weak", "Yes" },
new string[] { "Rain", "Mild", "High", "Weak", "Yes" },
new string[] { "Rain", "Cool", "Normal", "Weak", "Yes" },
new string[] { "Rain", "Cool", "Normal", "Strong", "No" },
new string[] { "Overcast", "Cool", "Normal", "Strong", "Yes" },
new string[] { "Sunny", "Mild", "High", "Weak", "No" },
new string[] { "Sunny", "Cool", "Normal", "Weak", "Yes" },
new string[] { "Rain", "Mild", "Normal", "Weak", "Yes" },
new string[] { "Sunny", "Mild", "Normal", "Strong", "Yes" },
new string[] { "Overcast", "Mild", "High", "Strong", "Yes" },
new string[] { "Overcast", "Hot", "Normal", "Weak", "Yes" },
new string[] { "Rain", "Mild", "High", "Strong", "No" },
};
// Create a new codification codebook to
// convert strings into discrete symbols
Codification codebook = new Codification(columnNames, data);
// Extract input and output pairs to train
int[][] symbols = codebook.Transform(data);
int[][] inputs = symbols.Get(null, 0, -1); // Gets all rows, from 0 to the last (but not the last)
int[] outputs = symbols.GetColumn(-1); // Gets only the last column
// Create a new Naive Bayes learning
var learner = new NaiveBayesLearning();
NaiveBayes nb = learner.Learn(inputs, outputs);
// Consider we would like to know whether one should play tennis at a
// sunny, cool, humid and windy day. Let us first encode this instance
int[] instance = codebook.Translate("Sunny", "Cool", "High", "Strong");
// Let us obtain the numeric output that represents the answer
int c = nb.Decide(instance); // answer will be 0
// Now let us convert the numeric output to an actual "Yes" or "No" answer
string result = codebook.Translate("PlayTennis", c); // answer will be "No"
// We can also extract the probabilities for each possible answer
double[] probs = nb.Probabilities(instance); // { 0.795, 0.205 }
#endregion
Assert.AreEqual("No", result);
Assert.AreEqual(0, c);
Assert.AreEqual(0.795, probs[0], 1e-3);
Assert.AreEqual(0.205, probs[1], 1e-3);
Assert.AreEqual(1, probs.Sum(), 1e-10);
Assert.IsFalse(double.IsNaN(probs[0]));
Assert.AreEqual(2, probs.Length);
}
public void no_sample_test()
{
// Declare some boolean data
bool[,] source =
{
// v1,v2,v3,v4,v5,v6,v7,v8,result
{ true, true, false, true, true, false, false, false, false },
{ true, true, true, true, true, false, false, false, false },
{ true, false, true, true, true, false, false, true, false },
{ true, true, true, true, true, false, false, true, false },
{ false, false, true, true, true, false, false, true, false },
{ true, true, true, true, false, false, false, false, false },
{ false, true, true, false, true, false, false, false, false },
{ true, true, true, false, true, false, false, false, false },
{ false, true, true, false, true, false, false, true, false },
{ false, true, true, true, true, false, false, true, false },
{ false, true, true, false, false, false, false, false, false },
{ true, false, false, true, false, false, false, true, true },
{ true, true, false, true, false, false, false, true, true },
{ true, true, true, true, false, false, false, true, true },
{ false, true, true, true, false, true, true, true, true },
{ true, true, false, false, false, true, true, true, true },
{ false, true, false, false, false, true, true, true, true },
{ true, true, true, true, false, true, true, true, true },
{ false, false, false, false, false, true, true, true, true },
{ true, true, false, true, false, true, true, true, true },
{ false, true, false, true, false, true, true, true, true },
{ false, true, true, false, false, true, true, true, true },
};
// Evaluation of a single point
int[] sp = new[] { false, false, false, false, true, true, true, true }.ToInt32();
// Transform to integers, then to jagged (matrix with [][] instead of [,])
int[][] data = source.ToInt32().ToJagged();
// Classification setup
var inputs = data.Get(null, 0, 8); // select all rows, with cols 0 to 8
var outputs = data.GetColumn(8); // select last column
var learner2 = new NaiveBayesLearning <GeneralDiscreteDistribution, GeneralDiscreteOptions, int>();
learner2.Options.InnerOption.UseLaplaceRule = true;
learner2.Distribution = (i, j) => new GeneralDiscreteDistribution(symbols: 2);
learner2.ParallelOptions.MaxDegreeOfParallelism = 1;
var nb2 = learner2.Learn(inputs, outputs);
test(nb2, inputs, sp);
var learner1 = new NaiveBayesLearning();
learner1.Options.InnerOption.UseLaplaceRule = true;
learner2.ParallelOptions.MaxDegreeOfParallelism = 1;
var nb1 = learner1.Learn(inputs, outputs);
test(nb1, inputs, sp);
}
public void buildModel()
{
// Now, let's create the forest learning algorithm
var teacher = new NaiveBayesLearning <NormalDistribution>();
// Finally, learn a random forest from data
this.nb = teacher.Learn(inputs, outputs);
}
public void runNaiveBayes()
{
codebook = new Codification(trainingData, "Feature1", "Feature2", "GeneratedByProgram");
// Training data to symbol
DataTable trainingsymbols = codebook.Apply(trainingData);;
int[][] trainingInputs = trainingsymbols.ToJagged <int>("Feature1", "Feature2");
int[] trainingOutputs = trainingsymbols.ToArray <int>("GeneratedByProgram");
// Create a new Naive Bayes learning
var learner = new NaiveBayesLearning();
learner.Options.InnerOption.UseLaplaceRule = true;
// We learn the algorithm:
NaiveBayes nb = learner.Learn(trainingInputs, trainingOutputs);
DataTable testdata = new DataTable("Sample Data");
testdata.Columns.Add("Feature1", "Feature2", "GeneratedByProgram");
testdata.Rows.Add("This", " is real", "No");
testdata.Rows.Add("a", "8", "Yes");
testdata.Rows.Add("b", "2000", "Yes");
testdata.Rows.Add("a", "9", "Yes");
testdata.Rows.Add("a", "90", "Yes");
testdata.Rows.Add("a", "12", "Yes");
testdata.Rows.Add("b", "15", "Yes");
testdata.Rows.Add("b", "18", "Yes");
testdata.Rows.Add("b", "200", "Yes");
testdata.Rows.Add("a", "5", "Yes");
testdata.Rows.Add("a", "62", "Yes");
testdata.Rows.Add("b", "5000", "Yes");
testdata.Rows.Add("b", "17", "Yes");
testdata.Rows.Add("b", "62", "Yes");
testdata.Rows.Add("b", "90", "Yes");
testdata.Rows.Add("b", "123", "Yes");
testdata.Rows.Add("This", " is Ok", "Yes");
testdata.Rows.Add("b", "1", "Yes");
testdata.Rows.Add("b", "64", "Yes");
testdata.Rows.Add("I ", "am god", "No");
testdata.Rows.Add("b", "33", "Yes");
String[] inst = { "b", "15" };
testForInstance(nb, inst, "Yes");
DataTable testsymbols = codebook.Apply(testdata);
int[][] testInput = testsymbols.ToJagged <int>("Feature1", "Feature2");
int[] testOutput = testsymbols.ToArray <int>("GeneratedByProgram");
int[] answers = nb.Decide(testInput);
Console.WriteLine("\n Accuracy (Tested on 20 data set): " + calculateAccuracy(answers, testOutput));
}
private NaiveBayes <NormalDistribution> LearnNB(double[][] XKnownTrainSet, int[] YKnownTrainSet)
{
var NBLearning = new NaiveBayesLearning <NormalDistribution>();
NBLearning.Options.InnerOption = new NormalOptions {
Regularization = 1e-6,
};
return(NBLearning.Learn(XKnownTrainSet, YKnownTrainSet));
}
//Make this class a singleton so that it is not retrained for every class it is used by
private TextAnalyzer()
{
//Usage of a Naive Bayes classifier
//Create the trainer, allowing for some regularlizatiton
var teacher = new NaiveBayesLearning <NormalDistribution, NormalOptions>()
{
Options = { InnerOption = { Regularization = 1e-6 } }
};
//Read in the training data and stop words
string liberalTrainingPath = System.Web.Hosting.HostingEnvironment.MapPath(@"~/Data/liberal_training.txt");
string conservativeTrainingPath = System.Web.Hosting.HostingEnvironment.MapPath(@"~/Data/conservative_training.txt");
string stopWordsPath = System.Web.Hosting.HostingEnvironment.MapPath(@"~/Data/stop_words.txt");
string[] liberalSamples = File.ReadAllLines(liberalTrainingPath);
string[] conservativeSamples = File.ReadAllLines(conservativeTrainingPath);
stopWords = File.ReadAllLines(stopWordsPath);
//Concat the samples into one array (They are first read into their own array to allow us to know the amount of samples in each file)
string[] samples = liberalSamples.Concat(conservativeSamples).ToArray();
//Break the text up into individual words
string[][] words = samples.Tokenize();
//If for some reason we didn't actually read any training data, throw an exception cuz the classifier wont work
if (words.Length == 0)
{
throw new Exception("No training data for TextAnalyzer");
}
//Remove common english words
words = TrimStopWords(words);
//Create a bag of words using the tokenized sample data
bagOfWords = new BagOfWords();
bagOfWords.Learn(words);
//Populate the output array using the known lengths of the sample files
int[] outputs = new int[samples.Length];
for (int i = 0; i < samples.Length; i++)
{
if (i < liberalSamples.Length)
{
outputs[i] = 0;
}
else
{
outputs[i] = 1;
}
}
//Train the classifier
double[][] inputs = bagOfWords.Transform(words);
nbClassifier = teacher.Learn(inputs, outputs);
}
public void Learn()
{
DataTable symbols = codeBook.Apply(data);
int[][] inputs = symbols.ToJagged <int>(headers);
int[] outputs = symbols.ToArray <int>(headerToPredict);
var learner = new NaiveBayesLearning();
nativeBayes = learner.Learn(inputs, outputs);
}
public void ComputeTest3()
{
#region doc_multiclass
// Let's say we have the following data to be classified
// into three possible classes. Those are the samples:
//
int[][] inputs =
{
// input output
new int[] { 0, 1, 1, 0 }, // 0
new int[] { 0, 1, 0, 0 }, // 0
new int[] { 0, 0, 1, 0 }, // 0
new int[] { 0, 1, 1, 0 }, // 0
new int[] { 0, 1, 0, 0 }, // 0
new int[] { 1, 0, 0, 0 }, // 1
new int[] { 1, 0, 0, 0 }, // 1
new int[] { 1, 0, 0, 1 }, // 1
new int[] { 0, 0, 0, 1 }, // 1
new int[] { 0, 0, 0, 1 }, // 1
new int[] { 1, 1, 1, 1 }, // 2
new int[] { 1, 0, 1, 1 }, // 2
new int[] { 1, 1, 0, 1 }, // 2
new int[] { 0, 1, 1, 1 }, // 2
new int[] { 1, 1, 1, 1 }, // 2
};
int[] outputs = // those are the class labels
{
0, 0, 0, 0, 0,
1, 1, 1, 1, 1,
2, 2, 2, 2, 2,
};
// Let us create a learning algorithm
var learner = new NaiveBayesLearning();
// and teach a model on the data examples
NaiveBayes nb = learner.Learn(inputs, outputs);
// Now, let's test the model output for the first input sample:
int answer = nb.Decide(new int[] { 0, 1, 1, 0 }); // should be 1
#endregion
double error = new ZeroOneLoss(outputs).Loss(nb.Decide(inputs));
Assert.AreEqual(0, error);
for (int i = 0; i < inputs.Length; i++)
{
error = nb.Compute(inputs[i]);
double expected = outputs[i];
Assert.AreEqual(expected, error);
}
}
public override Task <List <GeneralConfusionMatrix> > ComputeFoldedConfusionMatrixAsync(ClassificationModel classificationModel, int folds)
{
return(Task.Factory.StartNew(() =>
{
int numFeatures = classificationModel.FeatureVectors.Count;
double[][] input = new double[numFeatures][];
int[] responses = new int[numFeatures];
for (int featureIndex = 0; featureIndex < classificationModel.FeatureVectors.Count; ++featureIndex)
{
var featureVector = classificationModel.FeatureVectors[featureIndex];
input[featureIndex] = Array.ConvertAll(featureVector.FeatureVector.BandIntensities, s => (double)s / ushort.MaxValue);
responses[featureIndex] = featureVector.FeatureClass;
}
List <GeneralConfusionMatrix> confusionMatrices = new List <GeneralConfusionMatrix>();
// Create a new Cross-validation algorithm passing the data set size and the number of folds
var crossvalidation = new CrossValidation(input.Length, folds);
crossvalidation.Fitting = delegate(int k, int[] indicesTrain, int[] indicesValidation)
{
// Lets now grab the training data:
var trainingInputs = input.Get(indicesTrain);
var trainingOutputs = responses.Get(indicesTrain);
// And now the validation data:
var validationInputs = input.Get(indicesValidation);
var validationOutputs = responses.Get(indicesValidation);
NaiveBayesLearning <NormalDistribution> learning = new NaiveBayesLearning <NormalDistribution>();
var bayes = learning.Learn(trainingInputs, trainingOutputs);
var predictedTraining = bayes.Decide(trainingInputs);
var predictedValidation = bayes.Decide(validationInputs);
double trainingError = new ZeroOneLoss(trainingOutputs).Loss(predictedTraining);
double validationError = new ZeroOneLoss(validationOutputs).Loss(predictedValidation);
GeneralConfusionMatrix confusionMatrix = new GeneralConfusionMatrix(Enum.GetValues(typeof(LandcoverTypeViewModel)).Length - 1, validationOutputs, predictedValidation);
confusionMatrices.Add(confusionMatrix);
// Return a new information structure containing the model and the errors achieved.
return new CrossValidationValues(trainingError, validationError);
};
crossvalidation.Compute();
return confusionMatrices;
}));
}
private void btLearn_Click(object sender, EventArgs e)
{
mDT = (DataTable)dataGridView1.DataSource;
double[][] inputs = mDT.ToJagged <double>("Height", "Weight", "FootSize");
int[] output = mDT.ToArray <int>("Sex");
var learner = new NaiveBayesLearning <NormalDistribution, NormalOptions>();
learner.Options.InnerOption.Regularization = 1e-5;
nb = learner.Learn(inputs, output);
}
private void Train(IEnumerable <SubstanceData> trainingDataset)
{
double[][] inputs = trainingDataset.Select(x => new double[] { x.Type, x.Concentration }).ToArray();
int[] outputs = trainingDataset.Select(x => x.IsDangerous ? 1 : 0).ToArray();
NaiveBayesLearning <NormalDistribution> naiveBayesTeacher = new NaiveBayesLearning <NormalDistribution>();
naiveBayesTeacher.Options.InnerOption = new NormalOptions()
{
Regularization = 1e-5
};
this._naiveBayesModel = naiveBayesTeacher.Learn(inputs, outputs);
}
public void Update(TransportTruck transportTruck)
{
var translatedData = Parse(transportTruck.Changes.Cast <RecordData>());
var itemModel = _learner.Learn(translatedData.x, translatedData.y);
if (!_bayesianModel.ContainsKey(transportTruck.Id))
{
_bayesianModel.Add(transportTruck.Id, itemModel);
return;
}
_bayesianModel[transportTruck.Id] = itemModel;
}
public NaiveBayes <NormalDistribution> MachineLearning()
{
var teacher = new NaiveBayesLearning <NormalDistribution>();
// Set options for the component distributions
teacher.Options.InnerOption = new NormalOptions
{
Regularization = 1e-5 // to avoid zero variances
};
// Learn the naive Bayes model
NaiveBayes <NormalDistribution> bayes = teacher.Learn(DataTrainInput, DataTrainOutput);
return(bayes);
}
public void should_not_allow_negative_classes()
{
double[][] inputs =
{
new double[] { 0, 0 },
new double[] { 0, 1 },
new double[] { 1, 0 },
new double[] { 1, 1 },
};
int[] outputs = { -1, 1, 1, -1 };
var teacher = new NaiveBayesLearning <NormalDistribution>();
Assert.Throws <ArgumentException>(() => teacher.Learn(inputs, outputs));
}
public TrainerHelper Train(System.Data.DataTable table, string columnName)
{
var container = new TrainerHelper();
var trainingCodification = new Codification()
{
DefaultMissingValueReplacement = Double.NaN
};
trainingCodification.Learn(table);
DataTable symbols = trainingCodification.Apply(table);
container.columnNamesArray =
table.Columns.Cast <DataColumn>().Select(x => x.ColumnName).Where(s => s != columnName).ToArray();
var columnOrdinal = table.Columns[columnName].Ordinal;
double[][] tempInputs = symbols.ToJagged(container.columnNamesArray);
double[][] inputs = new double[tempInputs.Length][];
for (var i = 0; i < tempInputs.Length; i++)
{
var flattened = this.ExpandRow(trainingCodification, tempInputs[i], columnOrdinal);
inputs[i] = flattened;
}
int[] outputs = symbols.ToArray <int>(columnName);
var teacher = new NaiveBayesLearning <NormalDistribution>();
// Set options for the component distributions
teacher.Options.InnerOption = new NormalOptions
{
Regularization = 1e-5 // to avoid zero variances
};
if (inputs.Length > 0)
{
NaiveBayes <NormalDistribution> learner = teacher.Learn(inputs, outputs);
container.trainer = learner;
}
//var lbnr = new LowerBoundNewtonRaphson() { MaxIterations = 100, Tolerance = 1e-6 };
//var mlr = lbnr.Learn(inputs, outputs);
container.codification = trainingCodification;
container.symbols = symbols;
return(container);
}
public void Train(List <TrainingValue> trainingData)
{
List <DecisionVariable> trainingVariables = new List <DecisionVariable>();
for (int i = 0; i < featureSize; i++)
{
trainingVariables.Add(DecisionVariable.Continuous(i.ToString()));
}
tree = new DecisionTree(inputs: trainingVariables, classes: 2);
double[][] featuresArray = new double[trainingData.Count][];
int[] labels = new int[trainingData.Count];
for (int i = 0; i < featuresArray.Length; i++)
{
featuresArray[i] = trainingData[i].Features;
labels[i] = Convert.ToInt32(trainingData[i].State);
}
switch (type)
{
case ClassifierType.DecisionTree:
C45Learning teacher = new C45Learning(tree);
teacher.Learn(featuresArray, labels);
break;
case ClassifierType.LDA:
LinearDiscriminantAnalysis lda = new LinearDiscriminantAnalysis();
pipeline = lda.Learn(featuresArray, labels);
break;
case ClassifierType.SVM:
LinearCoordinateDescent svmLearner = new LinearCoordinateDescent();
svm = svmLearner.Learn(featuresArray, labels);
break;
case ClassifierType.Bayes:
NaiveBayesLearning <NormalDistribution> learner = new NaiveBayesLearning <NormalDistribution>();
bayes = learner.Learn(featuresArray, labels);
break;
}
Trained = true;
}
public override void DoTraining(DocumentSetCaseCollectionSet trainingSet, classifierTools tools, ILogBuilder logger)
{
var state = states.SetState(trainingSet, GetExperimentSufix());
if (isMultinominal)
{
NaiveBayesLearning <GeneralizedBetaDistribution> teacher = new NaiveBayesLearning <GeneralizedBetaDistribution>();
// Set options for the component distributions
teacher.Options.InnerOption = new NormalOptions
{
Regularization = 1e-5 // to avoid zero variances
};
// The following line is only needed to ensure reproducible results. Please remove it to enable full parallelization
teacher.ParallelOptions.MaxDegreeOfParallelism = 1; // (Remove, comment, or change this line to enable full parallelism)
_teacher = teacher;
// Learn a machine
// state.machine = teacher.Learn(state.data.inputs, state.data.outputs);
}
else
{
NaiveBayesLearning <NormalDistribution> teacher = new NaiveBayesLearning <NormalDistribution>();
// Set options for the component distributions
teacher.Options.InnerOption = new NormalOptions
{
Regularization = 1e-5 // to avoid zero variances
};
// The following line is only needed to ensure reproducible results. Please remove it to enable full parallelization
teacher.ParallelOptions.MaxDegreeOfParallelism = 1; // (Remove, comment, or change this line to enable full parallelism)
_teacher = teacher;
// Learn a machine
state.machine = teacher.Learn(state.data.inputs, state.data.outputs);
}
state.SaveState();
}
public static void learnNaiveBayes(double percent, string newsType, Guid companyId)
{
try
{
var classNames = new string[] { "Percent", "NewsType", "CompanyId" };
DataTable dt = new DataTable();
dt.Columns.Add("Percent");
dt.Columns.Add("NewsType");
dt.Columns.Add("CompanyId");
DataRow dr = dt.NewRow();
dr["Percent"] = percent.ToString();
dr["NewsType"] = newsType;
dr["CompanyId"] = companyId.ToString();
dt.Rows.Add(dr);
// Creates a matrix from the source data table
//double[,] table = dt.ToMatrix(out columnNames);
// Get only the input vector values
//double[][] inputs = table.GetColumns(0, 1).ToJagged();
// Get only the label outputs
// int[] outputs = table.GetColumn(2).ToInt32();
if (codebook == null)
{
codebook = new Codification(dt, "NewsType", "CompanyId", "Percent");
}
DataTable symbols = codebook.Apply(dt);
int[][] inputs = symbols.ToJagged <int>("NewsType", "CompanyId");
int[] outputs = symbols.ToArray <int>("Percent");
//var teacher = new NaiveBayesLearning<NormalDistribution>();
var teacher = new NaiveBayesLearning();
naiveBayes = teacher.Learn(inputs, outputs);
}
catch (Exception e)
{
}
}
static void Main(string[] args)
{
DataTable data = new DataTable("Categories of words");
data.Columns.Add("Category", "Word");
List <InputData> words = ExcelDataProvider.GetData(@"C:\Users\Дарья\Desktop\AdverbNoun.xlsx", 0);
foreach (var word in words)
{
data.Rows.Add(word.Category, word.Word);
}
Codification codebook = new Codification(data, "Category", "Word");
DataTable symbols = codebook.Apply(data);
int[][] inputs = symbols.ToJagged <int>("Category");
int[] outputs = symbols.ToArray <int>("Word");
var learner = new NaiveBayesLearning();
NaiveBayes nb = learner.Learn(inputs, outputs);
data = new DataTable("Categories of words");
data.Columns.Add("Category", "Word");
words = ExcelDataProvider.GetData(@"C:\Users\Дарья\Desktop\TestAdverbNoun.xlsx", 0);
foreach (var word in words)
{
data.Rows.Add(word.Category, word.Word);
}
int[] instance = codebook.Translate("helpful");
int c = nb.Decide(instance);
string result = codebook.Translate("Category", c);
double[] probs = nb.Probabilities(instance);
Console.WriteLine(0);
}
public void no_samples_for_class_double()
{
double[][] inputs =
{
new double[] { 1, 1 }, // 0
new double[] { 1, 1 }, // 0
new double[] { 1, 1 }, // 2
};
int[] outputs =
{
0, 0, 2
};
var teacher = new NaiveBayesLearning <NormalDistribution>();
Assert.Throws <ArgumentException>(() => teacher.Learn(inputs, outputs),
"There are no samples for class label {0}. Please make sure that class " +
"labels are contiguous and there is at least one training sample for each label.", 1);
}
public void learn_test_mitchell()
{
#region doc_mitchell_1
// We will represent Mitchell's Tennis example using a DataTable. However,
// the use of a DataTable is not required in order to use the Naive Bayes.
// Please take a look at the other examples below for simpler approaches.
DataTable data = new DataTable("Mitchell's Tennis Example");
data.Columns.Add("Day", "Outlook", "Temperature", "Humidity", "Wind", "PlayTennis");
// We will set Temperature and Humidity to be continuous
data.Columns["Temperature"].DataType = typeof(double);
data.Columns["Humidity"].DataType = typeof(double);
// Add some data
data.Rows.Add("D1", "Sunny", 38.0, 96.0, "Weak", "No");
data.Rows.Add("D2", "Sunny", 39.0, 90.0, "Strong", "No");
data.Rows.Add("D3", "Overcast", 38.0, 75.0, "Weak", "Yes");
data.Rows.Add("D4", "Rain", 25.0, 87.0, "Weak", "Yes");
data.Rows.Add("D5", "Rain", 12.0, 30.0, "Weak", "Yes");
data.Rows.Add("D6", "Rain", 11.0, 35.0, "Strong", "No");
data.Rows.Add("D7", "Overcast", 10.0, 40.0, "Strong", "Yes");
data.Rows.Add("D8", "Sunny", 24.0, 90.0, "Weak", "No");
data.Rows.Add("D9", "Sunny", 12.0, 26.0, "Weak", "Yes");
data.Rows.Add("D10", "Rain", 25, 30.0, "Weak", "Yes");
data.Rows.Add("D11", "Sunny", 26.0, 40.0, "Strong", "Yes");
data.Rows.Add("D12", "Overcast", 27.0, 97.0, "Strong", "Yes");
data.Rows.Add("D13", "Overcast", 39.0, 41.0, "Weak", "Yes");
data.Rows.Add("D14", "Rain", 23.0, 98.0, "Strong", "No");
#endregion
#region doc_mitchell_2
// Create a new codification codebook to
// convert strings into discrete symbols
Codification codebook = new Codification(data);
#endregion
#region doc_mitchell_3
// Some distributions require constructor parameters, and as such, cannot
// be automatically initialized by the learning algorithm. For this reason,
// we might need to specify how each component should be initialized:
IUnivariateFittableDistribution[] priors =
{
new GeneralDiscreteDistribution(codebook["Outlook"].Symbols), // 3 possible values (Sunny, overcast, rain)
new NormalDistribution(), // Continuous value (Celsius)
new NormalDistribution(), // Continuous value (percentage)
new GeneralDiscreteDistribution(codebook["Wind"].Symbols) // 2 possible values (Weak, strong)
};
// Create a new Naive Bayes classifiers for the two classes
var learner = new NaiveBayesLearning<IUnivariateFittableDistribution>()
{
// Tell the learner how to initialize the distributions
Distribution = (classIndex, variableIndex) => priors[variableIndex]
};
// Extract symbols from data and train the classifier
DataTable symbols = codebook.Apply(data);
double[][] inputs = symbols.ToArray("Outlook", "Temperature", "Humidity", "Wind");
int[] outputs = symbols.ToArray<int>("PlayTennis");
// Learn the Naive Bayes model
var naiveBayes = learner.Learn(inputs, outputs);
#endregion
#region doc_mitchell_4
// Create an instance representing a "sunny, cool, humid and windy day":
double[] instance = new double[]
{
codebook.Translate(columnName:"Outlook", value:"Sunny"), //n 0
12.0,
90.0,
codebook.Translate(columnName:"Wind", value:"Strong") // 1
};
// We can obtain a class prediction using
int predicted = naiveBayes.Decide(instance);
// Or compute probabilities of each class using
double[] probabilities = naiveBayes.Probabilities(instance);
// Or obtain the log-likelihood of prediction
double ll = naiveBayes.LogLikelihood(instance);
// Finally, the result can be translated back using
string result = codebook.Translate("PlayTennis", predicted); // Should be "No"
#endregion
Assert.AreEqual("No", result);
Assert.AreEqual(0, predicted);
Assert.AreEqual(0.840, probabilities[0], 1e-3);
Assert.AreEqual(-10.493243476691351, ll, 1e-6);
Assert.AreEqual(1, probabilities.Sum(), 1e-10);
Assert.AreEqual(2, probabilities.Length);
}
public void ComputeTest()
{
#region doc_mitchell
DataTable data = new DataTable("Mitchell's Tennis Example");
data.Columns.Add("Day", "Outlook", "Temperature", "Humidity", "Wind", "PlayTennis");
data.Rows.Add("D1", "Sunny", "Hot", "High", "Weak", "No");
data.Rows.Add("D2", "Sunny", "Hot", "High", "Strong", "No");
data.Rows.Add("D3", "Overcast", "Hot", "High", "Weak", "Yes");
data.Rows.Add("D4", "Rain", "Mild", "High", "Weak", "Yes");
data.Rows.Add("D5", "Rain", "Cool", "Normal", "Weak", "Yes");
data.Rows.Add("D6", "Rain", "Cool", "Normal", "Strong", "No");
data.Rows.Add("D7", "Overcast", "Cool", "Normal", "Strong", "Yes");
data.Rows.Add("D8", "Sunny", "Mild", "High", "Weak", "No");
data.Rows.Add("D9", "Sunny", "Cool", "Normal", "Weak", "Yes");
data.Rows.Add("D10", "Rain", "Mild", "Normal", "Weak", "Yes");
data.Rows.Add("D11", "Sunny", "Mild", "Normal", "Strong", "Yes");
data.Rows.Add("D12", "Overcast", "Mild", "High", "Strong", "Yes");
data.Rows.Add("D13", "Overcast", "Hot", "Normal", "Weak", "Yes");
data.Rows.Add("D14", "Rain", "Mild", "High", "Strong", "No");
#endregion
#region doc_codebook
// Create a new codification codebook to
// convert strings into discrete symbols
Codification codebook = new Codification(data,
"Outlook", "Temperature", "Humidity", "Wind", "PlayTennis");
// Extract input and output pairs to train
DataTable symbols = codebook.Apply(data);
int[][] inputs = symbols.ToArray<int>("Outlook", "Temperature", "Humidity", "Wind");
int[] outputs = symbols.ToArray<int>("PlayTennis");
#endregion
#region doc_learn
// Create a new Naive Bayes learning
var learner = new NaiveBayesLearning();
// Learn a Naive Bayes model from the examples
NaiveBayes nb = learner.Learn(inputs, outputs);
#endregion
#region doc_test
// Consider we would like to know whether one should play tennis at a
// sunny, cool, humid and windy day. Let us first encode this instance
int[] instance = codebook.Translate("Sunny", "Cool", "High", "Strong");
// Let us obtain the numeric output that represents the answer
int c = nb.Decide(instance); // answer will be 0
// Now let us convert the numeric output to an actual "Yes" or "No" answer
string result = codebook.Translate("PlayTennis", c); // answer will be "No"
// We can also extract the probabilities for each possible answer
double[] probs = nb.Probabilities(instance); // { 0.795, 0.205 }
#endregion
Assert.AreEqual("No", result);
Assert.AreEqual(0, c);
Assert.AreEqual(0.795, probs[0], 1e-3);
Assert.AreEqual(0.205, probs[1], 1e-3);
Assert.AreEqual(1, probs.Sum(), 1e-10);
Assert.IsFalse(double.IsNaN(probs[0]));
Assert.AreEqual(2, probs.Length);
}
public void laplace_smoothing_missing_sample()
{
#region doc_laplace
// To test the effectiveness of the Laplace rule for when
// an example of a symbol is not present in the training set,
// lets create dataset where the second column could contain
// values 0, 1 or 2 but only actually contains examples with
// containing 1 and 2:
int[][] inputs =
{
// input output
new [] { 0, 1 }, // 0
new [] { 0, 2 }, // 0
new [] { 0, 1 }, // 0
new [] { 1, 2 }, // 1
new [] { 0, 2 }, // 1
new [] { 0, 2 }, // 1
new [] { 1, 1 }, // 2
new [] { 0, 1 }, // 2
new [] { 1, 1 }, // 2
};
int[] outputs = // those are the class labels
{
0, 0, 0, 1, 1, 1, 2, 2, 2,
};
// Since the data is not enough to determine which symbols we are
// expecting in our model, we will have to specify the model by
// hand. The first column can assume 2 different values, whereas
// the third column can assume 3:
var bayes = new NaiveBayes(classes: 3, symbols: new[] { 2, 3 });
// Now we can create a learning algorithm
var learning = new NaiveBayesLearning()
{
Model = bayes
};
// Enable the use of the Laplace rule
learning.Options.InnerOption.UseLaplaceRule = true;
// Learn the Naive Bayes model
learning.Learn(inputs, outputs);
// Estimate a sample with 0 in the second col
int answer = bayes.Decide(new int[] { 0, 1 });
#endregion
Assert.AreEqual(0, answer);
double prob = bayes.Probability(new int[] { 0, 1 }, out answer);
Assert.AreEqual(0, answer);
Assert.AreEqual(0.52173913043478259, prob, 1e-10);
double error = new ZeroOneLoss(outputs)
{
Mean = true
}.Loss(bayes.Decide(inputs));
Assert.AreEqual(2 / 9.0, error);
}
/// <summary>
/// Creates and learns a Naive Bayes classifier to recognize
/// the previously loaded dataset using the current settings.
/// </summary>
///
private void btnCreate_Click(object sender, EventArgs e)
{
if (dgvLearningSource.DataSource == null)
{
MessageBox.Show("Please load some data first.");
return;
}
classNames = new string[] { "G1", "G2" };
// Finishes and save any pending changes to the given data
dgvLearningSource.EndEdit();
// Creates a matrix from the source data table
double[,] table = (dgvLearningSource.DataSource as DataTable).ToMatrix(out columnNames);
// Get only the input vector values
double[][] inputs = table.Submatrix(null, 0, 1).ToArray();
// Get only the label outputs
int[] outputs = table.GetColumn(2).ToInt32();
string[] colNames = columnNames.Submatrix(first: 2);
// Create the Bayes classifier and perform classification
var teacher = new NaiveBayesLearning<NormalDistribution>();
// Estimate the model using the data
bayes = teacher.Learn(inputs, outputs);
// Show the estimated distributions and class probabilities
dataGridView1.DataSource = new ArrayDataView(bayes.Distributions, colNames);
// Generate samples for class 1
var x1 = bayes.Distributions[0, 0].Generate(1000);
var y1 = bayes.Distributions[0, 1].Generate(1000);
// Generate samples for class 2
var x2 = bayes.Distributions[1, 0].Generate(1000);
var y2 = bayes.Distributions[1, 1].Generate(1000);
// Combine in a single graph
double[,] w1 = Matrix.Stack(x1, y1).Transpose();
double[,] w2 = Matrix.Stack(x2, y2).Transpose();
double[] z = Vector.Ones(2000);
for (int i = 0; i < 1000; i++)
z[i] = 0;
var a = Matrix.Stack<double>(new double[][,] { w1, w2 });
var graph = a.Concatenate(z);
CreateScatterplot(zedGraphControl2, graph);
lbStatus.Text = "Classifier created! See the other tabs for details!";
}
public void ComputeTest3()
{
#region doc_multiclass
// Let's say we have the following data to be classified
// into three possible classes. Those are the samples:
//
int[][] inputs =
{
// input output
new int[] { 0, 1, 1, 0 }, // 0
new int[] { 0, 1, 0, 0 }, // 0
new int[] { 0, 0, 1, 0 }, // 0
new int[] { 0, 1, 1, 0 }, // 0
new int[] { 0, 1, 0, 0 }, // 0
new int[] { 1, 0, 0, 0 }, // 1
new int[] { 1, 0, 0, 0 }, // 1
new int[] { 1, 0, 0, 1 }, // 1
new int[] { 0, 0, 0, 1 }, // 1
new int[] { 0, 0, 0, 1 }, // 1
new int[] { 1, 1, 1, 1 }, // 2
new int[] { 1, 0, 1, 1 }, // 2
new int[] { 1, 1, 0, 1 }, // 2
new int[] { 0, 1, 1, 1 }, // 2
new int[] { 1, 1, 1, 1 }, // 2
};
int[] outputs = // those are the class labels
{
0, 0, 0, 0, 0,
1, 1, 1, 1, 1,
2, 2, 2, 2, 2,
};
// Let us create a learning algorithm
var learner = new NaiveBayesLearning();
// and teach a model on the data examples
NaiveBayes nb = learner.Learn(inputs, outputs);
// Now, let's test the model output for the first input sample:
int answer = nb.Decide(new int[] { 0, 1, 1, 0 }); // should be 1
#endregion
double error = new ZeroOneLoss(outputs).Loss(nb.Decide(inputs));
Assert.AreEqual(0, error);
for (int i = 0; i < inputs.Length; i++)
{
error = nb.Compute(inputs[i]);
double expected = outputs[i];
Assert.AreEqual(expected, error);
}
}
public void learn_test_with_options()
{
#region doc_learn_options
// Let's say we have the following data to be classified
// into three possible classes. Those are the samples:
//
double[][] inputs =
{
// input output
new double[] { 0, 1, 1, 0 }, // 0
new double[] { 0, 1, 0, 0 }, // 0
new double[] { 0, 0, 1, 0 }, // 0
new double[] { 0, 1, 1, 0 }, // 0
new double[] { 0, 1, 0, 0 }, // 0
new double[] { 1, 0, 0, 0 }, // 1
new double[] { 1, 0, 0, 0 }, // 1
new double[] { 1, 0, 0, 1 }, // 1
new double[] { 0, 0, 0, 1 }, // 1
new double[] { 0, 0, 0, 1 }, // 1
new double[] { 1, 1, 1, 1 }, // 2
new double[] { 1, 0, 1, 1 }, // 2
new double[] { 1, 1, 0, 1 }, // 2
new double[] { 0, 1, 1, 1 }, // 2
new double[] { 1, 1, 1, 1 }, // 2
};
int[] outputs = // those are the class labels
{
0, 0, 0, 0, 0,
1, 1, 1, 1, 1,
2, 2, 2, 2, 2,
};
// Create a new Gaussian distribution naive Bayes learner
var teacher = new NaiveBayesLearning<NormalDistribution, NormalOptions>();
// Set options for the component distributions
teacher.Options.InnerOption.Regularization = 1e-5; // to avoid zero variances
// Learn the naive Bayes model
NaiveBayes<NormalDistribution> bayes = teacher.Learn(inputs, outputs);
// Use the model to predict class labels
int[] predicted = bayes.Decide(inputs);
// Estimate the model error. The error should be zero:
double error = new ZeroOneLoss(outputs).Loss(predicted);
// Now, let's test the model output for the first input sample:
int answer = bayes.Decide(new double[] { 1, 0, 0, 1 }); // should be 1
#endregion
Assert.AreEqual(0, error);
Assert.AreEqual(1, answer);
Assert.IsTrue(predicted.IsEqual(outputs));
}
public void no_sample_test()
{
// Declare some boolean data
bool[,] source =
{
// v1,v2,v3,v4,v5,v6,v7,v8,result
{ true, true, false, true, true, false, false, false, false },
{ true, true, true, true, true, false, false, false, false },
{ true, false, true, true, true, false, false, true, false },
{ true, true, true, true, true, false, false, true, false },
{ false, false, true, true, true, false, false, true, false },
{ true, true, true, true, false, false, false, false, false },
{ false, true, true, false, true, false, false, false, false },
{ true, true, true, false, true, false, false, false, false },
{ false, true, true, false, true, false, false, true, false },
{ false, true, true, true, true, false, false, true, false },
{ false, true, true, false, false, false, false, false, false },
{ true, false, false, true, false, false, false, true, true },
{ true, true, false, true, false, false, false, true, true },
{ true, true, true, true, false, false, false, true, true },
{ false, true, true, true, false, true, true, true, true },
{ true, true, false, false, false, true, true, true, true },
{ false, true, false, false, false, true, true, true, true },
{ true, true, true, true, false, true, true, true, true },
{ false, false, false, false, false, true, true, true, true },
{ true, true, false, true, false, true, true, true, true },
{ false, true, false, true, false, true, true, true, true },
{ false, true, true, false, false, true, true, true, true },
};
// Evaluation of a single point
int[] sp = new[] { false, false, false, false, true, true, true, true }.ToInt32();
// Transform to integers, then to jagged (matrix with [][] instead of [,])
int[][] data = source.ToInt32().ToJagged();
// Classification setup
var inputs = data.Get(null, 0, 8); // select all rows, with cols 0 to 8
var outputs = data.GetColumn(8); // select last column
var learner2 = new NaiveBayesLearning<GeneralDiscreteDistribution, GeneralDiscreteOptions, int>();
learner2.Options.InnerOption.UseLaplaceRule = true;
learner2.Distribution = (i, j) => new GeneralDiscreteDistribution(symbols: 2);
learner2.ParallelOptions.MaxDegreeOfParallelism = 1;
var nb2 = learner2.Learn(inputs, outputs);
test(nb2, inputs, sp);
var learner1 = new NaiveBayesLearning();
learner1.Options.InnerOption.UseLaplaceRule = true;
learner2.ParallelOptions.MaxDegreeOfParallelism = 1;
var nb1 = learner1.Learn(inputs, outputs);
test(nb1, inputs, sp);
}