/// <summary> /// Searches for the best split using a brute force approach. The searcher only considers splits /// when both the threshold value and the target value has changed. /// The implementation assumes that the features and targets have been sorted /// together using the features as sort criteria /// </summary> /// <param name="impurityCalculator"></param> /// <param name="feature"></param> /// <param name="targets"></param> /// <param name="parentInterval"></param> /// <param name="parentImpurity"></param> /// <returns></returns> public SplitResult FindBestSplit(IImpurityCalculator impurityCalculator, double[] feature, double[] targets, Interval1D parentInterval, double parentImpurity) { var bestSplitIndex = -1; var bestThreshold = 0.0; var bestImpurityImprovement = 0.0; var bestImpurityLeft = 0.0; var bestImpurityRight = 0.0; int prevSplit = parentInterval.FromInclusive; var prevValue = feature[prevSplit]; var prevTarget = targets[prevSplit]; impurityCalculator.UpdateInterval(parentInterval); for (int j = prevSplit + 1; j < parentInterval.ToExclusive; j++) { var currentValue = feature[j]; var currentTarget = targets[j]; if ((prevValue != currentValue) && (prevTarget != currentTarget)) { var currentSplit = j; var leftSize = (double)(currentSplit - parentInterval.FromInclusive); var rightSize = (double)(parentInterval.ToExclusive - currentSplit); if (Math.Min(leftSize, rightSize) >= m_minimumSplitSize) { impurityCalculator.UpdateIndex(currentSplit); if ((impurityCalculator.WeightedLeft < m_minimumLeafWeight) || (impurityCalculator.WeightedRight < m_minimumLeafWeight)) { continue; } var improvement = impurityCalculator.ImpurityImprovement(parentImpurity); if (improvement > bestImpurityImprovement) { var childImpurities = impurityCalculator.ChildImpurities(); // could be avoided bestImpurityImprovement = improvement; bestThreshold = (currentValue + prevValue) * 0.5; bestSplitIndex = currentSplit; bestImpurityLeft = childImpurities.Left; bestImpurityRight = childImpurities.Right; } prevSplit = j; } } prevValue = currentValue; prevTarget = currentTarget; } return(new SplitResult(bestSplitIndex, bestThreshold, bestImpurityImprovement, bestImpurityLeft, bestImpurityRight)); }
/// <summary> /// /// </summary> /// <param name="parentIndex"></param> /// <param name="nodeType"></param> /// <param name="interval"></param> /// <param name="impurity"></param> /// <param name="nodeDepth"></param> public DecisionNodeCreationItem(int parentIndex, NodePositionType nodeType, Interval1D interval, double impurity, int nodeDepth) { ParentIndex = parentIndex; NodeType = nodeType; Interval = interval; Impurity = impurity; NodeDepth = nodeDepth; }
/// <summary> /// Copies the provided indices from source to destination within the provided interval /// </summary> /// <typeparam name="T"></typeparam> /// <param name="indices"></param> /// <param name="source"></param> /// <param name="interval"></param> /// <param name="destination"></param> public static void IndexedCopy <T>(this int[] indices, T[] source, Interval1D interval, T[] destination) { for (int i = interval.FromInclusive; i < interval.ToExclusive; i++) { var index = indices[i]; destination[i] = source[index]; } }
/// <summary> /// Copies the provided indices from source to destination within the provided interval /// </summary> /// <param name="indices"></param> /// <param name="source"></param> /// <param name="interval"></param> /// <param name="destination"></param> public static void IndexedCopy(this int[] indices, F64MatrixColumnView source, Interval1D interval, double[] destination) { for (int i = interval.FromInclusive; i < interval.ToExclusive; i++) { var index = indices[i]; destination[i] = source[index]; } }
public void Interval1D_Equals() { var sut = Interval1D.Create(3, 5); var equal = Interval1D.Create(3, 5); var notEqual = Interval1D.Create(3, 4); Assert.IsTrue(sut.Equals(equal)); Assert.IsFalse(sut.Equals(notEqual)); }
/// <summary> /// 判断两个区域是否相交。 /// </summary> /// <param name="that">需要判断相交的另一个区域。</param> /// <returns>如果相交则返回 True,否则返回 False。</returns> public bool Intersect(Interval1D that) { if (Max < that.Min || that.Max < Min) { return(false); } return(true); }
public void Interval2D_Equals() { var sut = Interval2D.Create(Interval1D.Create(0, 5), Interval1D.Create(2, 5)); var equal = Interval2D.Create(Interval1D.Create(0, 5), Interval1D.Create(2, 5)); var notEqual = Interval2D.Create(Interval1D.Create(2, 5), Interval1D.Create(0, 5)); Assert.IsTrue(sut.Equals(equal)); Assert.IsFalse(sut.Equals(notEqual)); }
/// <summary> /// Initialize the calculator with targets, weights and work interval /// </summary> /// <param name="uniqueTargets"></param> /// <param name="targets"></param> /// <param name="weights"></param> /// <param name="interval"></param> public void Init(double[] uniqueTargets, double[] targets, double[] weights, Interval1D interval) { if (targets == null) { throw new ArgumentException("targets"); } if (weights == null) { throw new ArgumentException("weights"); } m_targets = targets; m_weights = weights; m_interval = interval; m_weightedTotal = 0.0; m_weightedLeft = 0.0; m_weightedRight = 0.0; m_meanLeft = 0.0; m_meanRight = 0.0; m_meanTotal = 0.0; m_sqSumLeft = 0.0; m_sqSumRight = 0.0; m_sqSumTotal = 0.0; m_varRight = 0.0; m_varLeft = 0.0; m_sumLeft = 0.0; m_sumRight = 0.0; m_sumTotal = 0.0; var w = 1.0; var weightsPresent = m_weights.Length != 0; for (int i = m_interval.FromInclusive; i < m_interval.ToExclusive; i++) { if (weightsPresent) { w = weights[i]; } var targetValue = targets[i]; var wTarget = w * targetValue; m_sumTotal += wTarget; m_sqSumTotal += wTarget * targetValue; m_weightedTotal += w; } m_meanTotal = m_sumTotal / m_weightedTotal; m_currentPosition = m_interval.FromInclusive; this.Reset(); }
/// <summary> /// Initialize the calculator with targets, weights and work interval /// </summary> /// <param name="targetNames"></param> /// <param name="targets"></param> /// <param name="weights"></param> /// <param name="interval"></param> public void Init(double[] targetNames, double[] targets, double[] weights, Interval1D interval) { if (targets == null) { throw new ArgumentException("targets"); } if (weights == null) { throw new ArgumentException("weights"); } if (targetNames == null) { throw new ArgumentException("uniqueTargets"); } m_targets = targets; m_weights = weights; m_targetNames = targetNames; m_interval = interval; SetMinMaxTargetNames(); if (m_targetIndexOffSet > 0) { m_targetIndexOffSet = 0; } else { m_targetIndexOffSet = m_targetIndexOffSet * -1; } m_weightedTargetCount.Reset(m_maxTargetNameIndex, m_targetIndexOffSet); m_weightedTargetCountLeft.Reset(m_maxTargetNameIndex, m_targetIndexOffSet); m_weightedTargetCountRight.Reset(m_maxTargetNameIndex, m_targetIndexOffSet); var w = 1.0; var weightsPresent = m_weights.Length != 0; m_weightedTotal = 0.0; m_weightedLeft = 0.0; m_weightedRight = 0.0; for (int i = m_interval.FromInclusive; i < m_interval.ToExclusive; i++) { if (weightsPresent) { w = weights[i]; } var targetIndex = (int)targets[i]; m_weightedTargetCount[targetIndex] += w; m_weightedTotal += w; } m_currentPosition = m_interval.FromInclusive; this.Reset(); }
/// <summary> /// Sums the values within the provided interval /// </summary> /// <param name="array"></param> /// <param name="interval"></param> /// <returns></returns> public static double Sum(this double[] array, Interval1D interval) { var sum = 0.0; for (int i = interval.FromInclusive; i < interval.ToExclusive; i++) { sum += array[i]; } return(sum); }
public void ArrayExtensions_CopyTo() { var values = new int[] { 0, 1, 2, 3, 4, 5 }; var interval = Interval1D.Create(0, values.Length); var destination = new int[interval.Length]; values.CopyTo(interval, destination); CollectionAssert.AreEqual(destination, values); }
public unsafe void F64MatrixView_SubView() { var matrix = Matrix(); using (var pinnedMatrix = matrix.GetPinnedPointer()) { var subView = pinnedMatrix.View().View(Interval2D.Create(Interval1D.Create(0, 2), Interval1D.Create(0, 3))); var subMatrix = matrix.Rows(new int[] { 0, 1 }); AssertMatrixView(subMatrix, subView); } }
public void F64VectorView_SubView_End() { var vector = new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; using (var pinned = vector.GetPinnedPointer()) { var view = pinned.View().View(Interval1D.Create(7, 10)); var expected = new double[] { 7, 8, 9 }; AssertVectorView(expected, view); } }
public void ArrayExtensions_CopyTo_Interval() { var values = new int[] { 0, 1, 2, 3, 4, 5 }; var interval = Interval1D.Create(1, 5); var destination = new int[values.Length]; values.CopyTo(interval, destination); var expected = new int[] { 0, 1, 2, 3, 4, 0 }; CollectionAssert.AreEqual(expected, destination); }
public void ArrayExtensions_IndexedCopy_Interval() { var values = new int[] { 0, 10, 20, 30, 40, 50 }; var indices = new int[] { 1, 1, 2, 2, 2, 5 }; var interval = Interval1D.Create(1, 5); var destination = new int[values.Length]; indices.IndexedCopy(values, interval, destination); var expected = new int[] { 0, 10, 20, 20, 20, 0 }; CollectionAssert.AreEqual(expected, destination); }
/// <summary> /// Find the best split. /// </summary> /// <param name="impurityCalculator"> /// The impurity calculator. /// </param> /// <param name="feature"> /// The feature. /// </param> /// <param name="targets"> /// The targets. /// </param> /// <param name="parentInterval"> /// The parent interval. /// </param> /// <param name="parentImpurity"> /// The parent impurity. /// </param> /// <returns> /// The <see cref="SplitResult"/>. /// </returns> public SplitResult FindBestSplit( ITopPerformerFocusImpurityCalculator impurityCalculator, double[] feature, double[] targets, Interval1D parentInterval, double parentImpurity) { var bestKnownSplit = new SplitResult(-1, 0, 0, 0, 0); var prevSplitStartIndex = parentInterval.FromInclusive; var previousFeatureValue = feature[prevSplitStartIndex]; impurityCalculator.UpdateIntervalAndTargets(parentInterval, targets); for (var currentSplitIndex = prevSplitStartIndex + this.MinimumSplitSize; currentSplitIndex <= parentInterval.ToExclusive - this.MinimumSplitSize; currentSplitIndex++) { var currentFeatureValue = feature[currentSplitIndex]; if (Math.Abs(previousFeatureValue - currentFeatureValue) > 1e-10) { impurityCalculator.UpdateIndex(currentSplitIndex); if (impurityCalculator.WeightedLeft < this.MinimumLeafWeight || impurityCalculator.WeightedRight < this.MinimumLeafWeight) { continue; } var currentImprovement = impurityCalculator.ImpurityImprovement(parentImpurity); // check if the split is better than current best if (currentImprovement > bestKnownSplit.ImpurityImprovement) { var childImpurities = impurityCalculator.ChildImpurities(); var bestThreshold = (currentFeatureValue + previousFeatureValue) * 0.5; bestKnownSplit = new SplitResult( currentSplitIndex, bestThreshold, currentImprovement, childImpurities.Left, childImpurities.Right); } } previousFeatureValue = currentFeatureValue; } return(bestKnownSplit); }
void SelectNextRandomIndices(int[] candidateModelIndices) { if (m_selectWithReplacement) { for (int i = 0; i < candidateModelIndices.Length; i++) { candidateModelIndices[i] = m_random.Next(0, m_numberOfModelsToSelect); } } else { m_allIndices.Shuffle(m_random); m_allIndices.CopyTo(Interval1D.Create(0, m_numberOfModelsToSelect), candidateModelIndices); } }
public void NaiveSinglePassVarianceEntropyMetric_Impurity_Interval() { var set1 = new double[] { 0, 1, 2, 3, 4, 3, 2, 1, 0 }; var set2 = new double[] { 1, 1, 1, 1, 2, 2, 2, 2 }; var sut = new NaiveSinglePassVarianceImpurityMetric(); var interval = Interval1D.Create(2, 7); var val1 = sut.Impurity(set1, interval); Assert.AreEqual(0.69999999999999929, val1); var val2 = sut.Impurity(set2, interval); Assert.AreEqual(0.29999999999999982, val2); }
public void RegressionImpurityCalculator_NodeImpurity() { var values = new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, }; var parentInterval = Interval1D.Create(0, values.Length); var sut = new RegressionImpurityCalculator(); sut.Init(new double[0], values, new double[0], parentInterval); sut.UpdateIndex(50); var actual = sut.NodeImpurity(); Assert.AreEqual(0.66666666666666674, actual, 0.000001); }
public void ArrayExtensions_SortWith() { var values = new int[] { 0, 1, 2, 3, 4, 5 }; var keys = new int[] { 5, 4, 3, 2, 1, 0 }; var interval = Interval1D.Create(0, keys.Length); keys.SortWith(interval, values); var expectedKeys = new int[] { 0, 1, 2, 3, 4, 5 }; CollectionAssert.AreEqual(expectedKeys, keys); var expectedValues = new int[] { 5, 4, 3, 2, 1, 0 }; CollectionAssert.AreEqual(expectedValues, values); }
/// <inheritdoc /> public SplitResult FindBestSplit( TestImpurityCalculator impurityCalculator, double[] feature, double[] targets, Interval1D parentInterval, double parentImpurity) { Interlocked.Increment(ref this._callCount); this.CheckIfTargetsDoMatch(impurityCalculator, targets); return(this._splitSearcher.FindBestSplit( impurityCalculator, feature, targets, parentInterval, parentImpurity)); }
public void GiniClassificationImpurityCalculator_NodeImpurity() { var values = new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, }; var unique = values.Distinct().ToArray(); var parentInterval = Interval1D.Create(0, values.Length); var sut = new GiniClassificationImpurityCalculator(); sut.Init(unique, values, new double[0], parentInterval); sut.UpdateIndex(50); var actual = sut.NodeImpurity(); Assert.AreEqual(0.66666666666666674, actual, 0.000001); }
public void ArrayExtensions_IndexedCopy_ColumnView_Interval() { var values = new double[] { 0, 10, 20, 30, 40, 50 }; var matrix = new F64Matrix(values, 6, 1); var indices = new int[] { 1, 1, 2, 2, 2, 5 }; var destination = new double[values.Length]; var interval = Interval1D.Create(1, 5); using (var ptr = matrix.GetPinnedPointer()) { var view = ptr.View().ColumnView(0); indices.IndexedCopy(view, interval, destination); var expected = new double[] { 0, 10, 20, 20, 20, 0 }; CollectionAssert.AreEqual(expected, destination); } }
public void RegressionImpurityCalculator_LeafValue_Weighted() { var values = new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, }; var weights = values.Select(t => Weight(t)).ToArray(); var parentInterval = Interval1D.Create(0, values.Length); var sut = new RegressionImpurityCalculator(); sut.Init(new double[0], values, weights, parentInterval); var impurity = sut.NodeImpurity(); sut.UpdateIndex(50); var actual = sut.LeafValue(); Assert.AreEqual(1.75, actual, 0.000001); }
public void RegressionImpurityCalculator_ChildImpurities() { var values = new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, }; var parentInterval = Interval1D.Create(0, values.Length); var sut = new RegressionImpurityCalculator(); sut.Init(new double[0], values, new double[0], parentInterval); var impurity = sut.NodeImpurity(); sut.UpdateIndex(50); var actual = sut.ChildImpurities(); var expected = new ChildImpurities(0.0, -2.25); Assert.AreEqual(expected, actual); }
public void GiniClassificationImpurityCalculator_LeafValue_Weighted() { var values = new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, }; var unique = values.Distinct().ToArray(); var weights = values.Select(t => Weight(t)).ToArray(); var parentInterval = Interval1D.Create(0, values.Length); var sut = new GiniClassificationImpurityCalculator(); sut.Init(unique, values, weights, parentInterval); var impurity = sut.NodeImpurity(); sut.UpdateIndex(50); var actual = sut.LeafValue(); Assert.AreEqual(2.0, actual, 0.000001); }
public void GiniClassificationImpurityCalculator_ChildImpurities() { var values = new double[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, }; var unique = values.Distinct().ToArray(); var parentInterval = Interval1D.Create(0, values.Length); var sut = new GiniClassificationImpurityCalculator(); sut.Init(unique, values, new double[0], parentInterval); var impurity = sut.NodeImpurity(); sut.UpdateIndex(50); var actual = sut.ChildImpurities(); var expected = new ChildImpurities(0.0, .5); Assert.AreEqual(expected, actual); }
public void GiniImpurityMetric_Impurity_Interval() { var set1 = new double[] { 0, 1, 2, 3, 4, 3, 2, 1, 0 }; var set2 = new double[] { 1, 1, 1, 1, 2, 2, 2, 2 }; var set3 = new double[] { 1, 1, 1, 1, 1, 1, 1, 1 }; var sut = new GiniImpurityMetric(); var interval = Interval1D.Create(2, 7); var val1 = sut.Impurity(set1, interval); Assert.AreEqual(0.64, val1); var val2 = sut.Impurity(set2, interval); Assert.AreEqual(0.48, val2); var val3 = sut.Impurity(set3, interval); Assert.AreEqual(0.0, val3); }
public void GiniImpurityMetric_Impurity_Weights_None() { var set1 = new double[] { 0, 1, 2, 3, 4, 3, 2, 1, 0 }; var set2 = new double[] { 1, 1, 1, 1, 2, 2, 2, 2 }; var set3 = new double[] { 1, 1, 1, 1, 1, 1, 1, 1 }; var weights = new double[] { 1, 1, 1, 1, 1, 1, 1, 1, 1 }; var sut = new GiniImpurityMetric(); var val1 = sut.Impurity(set1, weights, Interval1D.Create(0, set1.Length)); Assert.AreEqual(0.79012345679012341, val1); var val2 = sut.Impurity(set2, weights, Interval1D.Create(0, set2.Length)); Assert.AreEqual(0.5, val2); var val3 = sut.Impurity(set3, weights, Interval1D.Create(0, set3.Length)); Assert.AreEqual(0.0, val3); }
public void GiniImpurityMetric_Impurity_Weights() { var set1 = new double[] { 0, 1, 2, 3, 4, 3, 2, 1, 0 }; var set2 = new double[] { 1, 1, 1, 1, 2, 2, 2, 2 }; var set3 = new double[] { 1, 1, 1, 1, 1, 1, 1, 1 }; var weights = new double[] { 3, 1, 4, 1, 0.5, 1, 2, 1, 10 }; var sut = new GiniImpurityMetric(); var val1 = sut.Impurity(set1, weights, Interval1D.Create(0, set1.Length)); Assert.AreEqual(0.96921684019918519, val1); var val2 = sut.Impurity(set2, weights, Interval1D.Create(0, set2.Length)); Assert.AreEqual(0.82441700960219477, val2); var val3 = sut.Impurity(set3, weights, Interval1D.Create(0, set3.Length)); Assert.AreEqual(0.64883401920438954, val3); }