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