/**
* <summary> The satisfy method takes an {@link Instance} as an input.
* <p/>
* If defined {@link Attribute} value is a {@link DiscreteIndexedAttribute} it compares the index of {@link Attribute} of instance at the
* attributeIndex and the index of {@link Attribute} value and returns the result.
* <p/>
* If defined {@link Attribute} value is a {@link DiscreteAttribute} it compares the value of {@link Attribute} of instance at the
* attributeIndex and the value of {@link Attribute} value and returns the result.
* <p/>
* If defined {@link Attribute} value is a {@link ContinuousAttribute} it compares the value of {@link Attribute} of instance at the
* attributeIndex and the value of {@link Attribute} value and returns the result according to the comparison character whether it is
* less than or greater than signs.</summary>
*
* <param name="instance">Instance to compare.</param>
* <returns>True if gicen instance satisfies the conditions.</returns>
*/
public bool Satisfy(Instance.Instance instance)
{
if (_value is DiscreteIndexedAttribute discreteIndexedAttribute)
{
if (discreteIndexedAttribute.GetIndex() != -1)
{
return(((DiscreteIndexedAttribute)instance.GetAttribute(_attributeIndex)).GetIndex() ==
discreteIndexedAttribute.GetIndex());
}
return(true);
}
if (_value is DiscreteAttribute discreteAttribute)
{
return(((DiscreteAttribute)instance.GetAttribute(_attributeIndex)).GetValue()
== discreteAttribute.GetValue());
}
if (_value is ContinuousAttribute continuousAttribute)
{
if (_comparison == '<')
{
return(((ContinuousAttribute)instance.GetAttribute(_attributeIndex)).GetValue() <=
continuousAttribute.GetValue());
}
if (_comparison == '>')
{
return(((ContinuousAttribute)instance.GetAttribute(_attributeIndex)).GetValue() >
continuousAttribute.GetValue());
}
}
return(false);
}
/**
* <summary> Adds the attribute types according to given {@link Instance}. For instance, if the attribute type of given {@link Instance}
* is a Discrete type, it than adds a discrete attribute type to the list of attribute types.</summary>
*
* <param name="instance">{@link Instance} input.</param>
*/
private void SetDefinition(Instance.Instance instance)
{
var attributeTypes = new List <AttributeType>();
for (var i = 0; i < instance.AttributeSize(); i++)
{
if (instance.GetAttribute(i) is BinaryAttribute)
{
attributeTypes.Add(AttributeType.BINARY);
}
else
{
if (instance.GetAttribute(i) is DiscreteIndexedAttribute)
{
attributeTypes.Add(AttributeType.DISCRETE_INDEXED);
}
else
{
if (instance.GetAttribute(i) is DiscreteAttribute)
{
attributeTypes.Add(AttributeType.DISCRETE);
}
else
{
if (instance.GetAttribute(i) is ContinuousAttribute)
{
attributeTypes.Add(AttributeType.CONTINUOUS);
}
}
}
}
}
_definition = new DataDefinition(attributeTypes);
}
/**
* <summary> Calculates Euclidian distance between two instances. For continuous features: \sum_{i=1}^d (x_i^(1) - x_i^(2))^2,
* For discrete features: \sum_{i=1}^d 1(x_i^(1) == x_i^(2))</summary>
*
* <param name="instance1">First instance</param>
* <param name="instance2">Second instance</param>
* <returns>Euclidian distance between two instances.</returns>
*/
public double Distance(Instance.Instance instance1, Instance.Instance instance2)
{
double result = 0;
for (var i = 0; i < instance1.AttributeSize(); i++)
{
if (instance1.GetAttribute(i) is DiscreteAttribute && instance2.GetAttribute(i) is DiscreteAttribute)
{
if (((DiscreteAttribute)instance1.GetAttribute(i)).GetValue() != null &&
string.Compare(((DiscreteAttribute)instance1.GetAttribute(i)).GetValue(),
((DiscreteAttribute)instance2.GetAttribute(i)).GetValue(), StringComparison.Ordinal) != 0)
{
result += 1;
}
}
else
{
if (instance1.GetAttribute(i) is ContinuousAttribute && instance2.GetAttribute(i) is
ContinuousAttribute)
{
result += System.Math.Pow(
((ContinuousAttribute)instance1.GetAttribute(i)).GetValue() -
((ContinuousAttribute)instance2.GetAttribute(i)).GetValue(), 2);
}
}
}
return(result);
}
/**
* <summary> Normalizes the continuous attributes of a single instance. For all i, new x_i = (x_i - m_i) / s_i.</summary>
*
* <param name="instance">Instance whose attributes will be normalized.</param>
*/
protected override void ConvertInstance(Instance.Instance instance)
{
for (var i = 0; i < instance.AttributeSize(); i++)
{
if (instance.GetAttribute(i) is ContinuousAttribute)
{
var xi = (ContinuousAttribute)instance.GetAttribute(i);
var mi = (ContinuousAttribute)_averageInstance.GetAttribute(i);
var si = (ContinuousAttribute)_standardDeviationInstance.GetAttribute(i);
xi.SetValue((xi.GetValue() - mi.GetValue()) / si.GetValue());
}
}
}
/**
* <summary> Checks given instance's attribute and returns true if it is a discrete indexed attribute, false otherwise.</summary>
*
* <param name="instance">Instance to check.</param>
* <returns>True if instance is a discrete indexed attribute, false otherwise.</returns>
*/
public bool DiscreteCheck(Instance.Instance instance)
{
for (var i = 0; i < instance.AttributeSize(); i++)
{
if (instance.GetAttribute(i) is DiscreteAttribute && !(instance.GetAttribute(i) is
DiscreteIndexedAttribute))
{
return(false);
}
}
return(true);
}
/**
* <summary> Converts discrete attributes of a single instance to binary discrete version using 1-of-L encoding. For example, if
* an attribute has values red, green, blue; this attribute will be converted to 3 binary attributes where
* red will have the value true false false, green will have the value false true false, and blue will have the value false false true.</summary>
*
* <param name="instance">The instance to be converted.</param>
*/
protected override void ConvertInstance(Instance.Instance instance)
{
var size = instance.AttributeSize();
for (var i = 0; i < size; i++)
{
if (attributeDistributions[i].Count > 0)
{
var index = attributeDistributions[i].GetIndex(instance.GetAttribute(i).ToString());
for (var j = 0; j < attributeDistributions[i].Count; j++)
{
if (j != index)
{
instance.AddAttribute(new BinaryAttribute(false));
}
else
{
instance.AddAttribute(new BinaryAttribute(true));
}
}
}
}
RemoveDiscreteAttributes(instance, size);
}
/**
* <summary> Converts discrete attributes of a single instance to indexed version.</summary>
*
* <param name="instance">The instance to be converted.</param>
*/
protected override void ConvertInstance(Instance.Instance instance)
{
var size = instance.AttributeSize();
for (var i = 0; i < size; i++)
{
if (attributeDistributions[i].Count > 0)
{
var index = attributeDistributions[i].GetIndex(instance.GetAttribute(i).ToString());
instance.AddAttribute(new DiscreteIndexedAttribute(instance.GetAttribute(i).ToString(), index,
attributeDistributions[i].Count));
}
}
RemoveDiscreteAttributes(instance, size);
}
/**
* <summary> Checks the correctness of the attribute type, for instance, if the attribute of given instance is a Binary attribute,
* and the attribute type of the corresponding item of the data definition is also a Binary attribute, it then
* returns true, and false otherwise.</summary>
*
* <param name="instance">{@link Instance} to checks the attribute type.</param>
* <returns>true if attribute types of given {@link Instance} and data definition matches.</returns>
*/
private bool CheckDefinition(Instance.Instance instance)
{
for (var i = 0; i < instance.AttributeSize(); i++)
{
if (instance.GetAttribute(i) is BinaryAttribute)
{
if (_definition.GetAttributeType(i) != AttributeType.BINARY)
{
return(false);
}
}
else
{
if (instance.GetAttribute(i) is DiscreteIndexedAttribute)
{
if (_definition.GetAttributeType(i) != AttributeType.DISCRETE_INDEXED)
{
return(false);
}
}
else
{
if (instance.GetAttribute(i) is DiscreteAttribute)
{
if (_definition.GetAttributeType(i) != AttributeType.DISCRETE)
{
return(false);
}
}
else
{
if (instance.GetAttribute(i) is ContinuousAttribute)
{
if (_definition.GetAttributeType(i) != AttributeType.CONTINUOUS)
{
return(false);
}
}
}
}
}
}
return(true);
}
/**
* <summary> The logLikelihoodDiscrete method takes an {@link Instance} and a class label as inputs. First it gets the logarithm</summary>
* of given class label's probability via prior distribution as logLikelihood and gets the class attribute distribution of given class label.
* Then it loops times of given instance attribute size, and accumulates the logLikelihood by calculating the logarithm of
* corresponding attribute distribution's smoothed probability by using laplace smoothing on xi.
*
* <param name="classLabel">String input class label.</param>
* <param name="instance"> {@link Instance} input.</param>
* <returns>The log likelihood of given class label and {@link Instance}.</returns>
*/
private double LogLikelihoodDiscrete(string classLabel, Instance.Instance instance)
{
var logLikelihood = System.Math.Log(priorDistribution.GetProbability(classLabel));
var attributeDistributions = _classAttributeDistributions[classLabel];
for (var i = 0; i < instance.AttributeSize(); i++)
{
var xi = ((DiscreteAttribute)instance.GetAttribute(i)).GetValue();
logLikelihood += System.Math.Log(attributeDistributions[i].GetProbabilityLaplaceSmoothing(xi));
}
return(logLikelihood);
}
/**
* <summary> The logLikelihoodContinuous method takes an {@link Instance} and a class label as inputs. First it gets the logarithm</summary>
* of given class label's probability via prior distribution as logLikelihood. Then it loops times of given instance attribute size, and accumulates the
* logLikelihood by calculating -0.5 * ((xi - mi) / si )** 2).
*
* <param name="classLabel">String input class label.</param>
* <param name="instance"> {@link Instance} input.</param>
* <returns>The log likelihood of given class label and {@link Instance}.</returns>
*/
private double LogLikelihoodContinuous(string classLabel, Instance.Instance instance)
{
var logLikelihood = System.Math.Log(priorDistribution.GetProbability(classLabel));
for (var i = 0; i < instance.AttributeSize(); i++)
{
var xi = ((ContinuousAttribute)instance.GetAttribute(i)).GetValue();
var mi = _classMeans[classLabel].GetValue(i);
var si = _classDeviations[classLabel].GetValue(i);
logLikelihood += -0.5 * System.Math.Pow((xi - mi) / si, 2);
}
return(logLikelihood);
}
