public List <CategoricalDistribution> DoForwardBackward(object owner, IContextLookup globalVars)
{
var randomVariables = TemporalModel.TransitionModel.GetRandomVariables(owner, globalVars);
var transitionalModel = new FiniteBayesModel(TemporalModel.TransitionModel.GetNetwork(randomVariables));
randomVariables = TemporalModel.SensorModel.GetRandomVariables(owner, globalVars, randomVariables);
var sensoryModel = new FiniteBayesModel(TemporalModel.SensorModel.GetNetwork(randomVariables));
var temporalMap = TemporalModel.GetReverseTemporalMap(randomVariables);
var forwardBackwardAlgorithm = new ForwardBackward(transitionalModel, temporalMap, sensoryModel);
var objEvidences = new java.util.ArrayList(Evidences.Count);
foreach (List <PropositionInfo> propositions in Evidences)
{
var stepEvidences = new java.util.ArrayList(propositions.Count);
foreach (PropositionInfo proposition in propositions)
{
stepEvidences.add(proposition.GetProposition(owner, globalVars, randomVariables));
}
objEvidences.add(stepEvidences);
}
CategoricalDistribution objPrior = Prior.GetProbabilityTable(randomVariables);
return(forwardBackwardAlgorithm.forwardBackward(objEvidences, objPrior).toArray().Select(o => (CategoricalDistribution)o).ToList());
}
public NaiveBayesClassifier(DataSample[] samples, int classes, ColumnDataType[] columnDataTypes)
{
_classes = classes;
_distribution = new IDistribution[classes, columnDataTypes.Length];
_classesProbablityDistribution = new CategoricalDistribution(
samples.Select(item => item.ClassId).ToArray(), classes);
var splitDataPerClass = SplitDataPerClass(samples, _classes, columnDataTypes.Length);
var groups = GetClassGroups(samples, _classes);
for (int index = 0; index < columnDataTypes.Length; index++)
{
//var values = GetDataPerClass(samples, _classes, index);
Double[][] values = new double[classes][];
for (int classIndex = 0; classIndex < classes; classIndex++)
{
values[classIndex] = splitDataPerClass[index, classIndex];
}
//var values = splitDataPerClass[index,_]
if (values.All(item => item == null))
{
continue;
}
for (int classIndex = 0; classIndex < classes; classIndex++)
{
var itemsOnClass = values[classIndex] ?? new double[0];
if (!columnDataTypes[index].IsDiscrete)
{
_distribution[classIndex, index] = new GaussianDistribution(itemsOnClass);
}
else
{
_distribution[classIndex, index] =
new CategoricalDistribution(itemsOnClass.Select(Convert.ToInt32).ToArray(),
columnDataTypes[index].NumberOfCategories, groups[classIndex]);
}
}
}
}
public NaiveBayesClassifierOld(TableFixedData data)
{
_data = data;
var doubleConverter = new DoubleConverter();
_distribution = new IDistribution[data.ClassesValue.Length, data.Attributes.Length];
for (int index = 0; index < data.Attributes.Length; index++)
{
if (data.Attributes[index] == TableData.ClassAttributeName)
{
var column = data.GetColumn <int>(index);
_classesProbablityDistribution = new CategoricalDistribution(column, data.ClassesValue.Length);
}
else
{
var isColumnNumeric = data[0, index].IsNumeric();
if (isColumnNumeric)
{
var values = GetDataPerClass <double>(data, index, doubleConverter);
for (int classIndex = 0; classIndex < data.ClassesValue.Length; classIndex++)
{
_distribution[classIndex, index] = new GaussianDistribution(values[classIndex]);
}
}
else
{
var values = GetDataPerClass <string>(data, index);
for (int classIndex = 0; classIndex < data.ClassesValue.Length; classIndex++)
{
var categoryData = values[classIndex].Select(item => data.GetSymbol(item, index)).ToArray();
_distribution[classIndex, index] = new CategoricalDistribution(categoryData, categoryData.Length);
}
}
}
}
}
public override CategoricalDistribution multiplyByPOS(
CategoricalDistribution multiplier, params RandomVariable[] prodVarOrder)
{
return(pointwiseProductPOS((ProbabilityTable)multiplier, prodVarOrder));
}
public override CategoricalDistribution multiplyBy(CategoricalDistribution multiplier)
{
return(pointwiseProduct((ProbabilityTable)multiplier));
}
public override CategoricalDistribution divideBy(CategoricalDistribution divisor)
{
return(divideBy((ProbabilityTable)divisor));
}