use of org.knime.base.node.mine.treeensemble2.data.TreeNominalColumnData in project knime-core by knime.
the class TreeNominalColumnDataTest method testCalcBestSplitClassificationBinary.
/**
* Tests the method
* {@link TreeNominalColumnData#calcBestSplitClassification(DataMemberships, ClassificationPriors, TreeTargetNominalColumnData, RandomData)}
* using binary splits.
*
* @throws Exception
*/
@Test
public void testCalcBestSplitClassificationBinary() throws Exception {
final TreeEnsembleLearnerConfiguration config = createConfig(false);
Pair<TreeNominalColumnData, TreeTargetNominalColumnData> tennisData = tennisData(config);
TreeNominalColumnData columnData = tennisData.getFirst();
TreeTargetNominalColumnData targetData = tennisData.getSecond();
assertEquals(SplitCriterion.Gini, config.getSplitCriterion());
double[] rowWeights = new double[SMALL_COLUMN_DATA.length];
Arrays.fill(rowWeights, 1.0);
TreeData tennisTreeData = tennisTreeData(config);
IDataIndexManager indexManager = new DefaultDataIndexManager(tennisTreeData);
DataMemberships dataMemberships = new RootDataMemberships(rowWeights, tennisTreeData, indexManager);
ClassificationPriors priors = targetData.getDistribution(rowWeights, config);
SplitCandidate splitCandidate = columnData.calcBestSplitClassification(dataMemberships, priors, targetData, null);
assertNotNull(splitCandidate);
assertThat(splitCandidate, instanceOf(NominalBinarySplitCandidate.class));
assertTrue(splitCandidate.canColumnBeSplitFurther());
// manually via libre office calc
assertEquals(0.0689342404, splitCandidate.getGainValue(), 0.00001);
NominalBinarySplitCandidate binSplitCandidate = (NominalBinarySplitCandidate) splitCandidate;
TreeNodeNominalBinaryCondition[] childConditions = binSplitCandidate.getChildConditions();
assertEquals(2, childConditions.length);
assertArrayEquals(new String[] { "R" }, childConditions[0].getValues());
assertArrayEquals(new String[] { "R" }, childConditions[1].getValues());
assertEquals(SetLogic.IS_NOT_IN, childConditions[0].getSetLogic());
assertEquals(SetLogic.IS_IN, childConditions[1].getSetLogic());
BitSet inChild = columnData.updateChildMemberships(childConditions[0], dataMemberships);
DataMemberships child1Memberships = dataMemberships.createChildMemberships(inChild);
ClassificationPriors childTargetPriors = targetData.getDistribution(child1Memberships, config);
SplitCandidate splitCandidateChild = columnData.calcBestSplitClassification(child1Memberships, childTargetPriors, targetData, null);
assertNotNull(splitCandidateChild);
assertThat(splitCandidateChild, instanceOf(NominalBinarySplitCandidate.class));
// manually via libre office calc
assertEquals(0.0086419753, splitCandidateChild.getGainValue(), 0.00001);
inChild = columnData.updateChildMemberships(childConditions[1], dataMemberships);
DataMemberships child2Memberships = dataMemberships.createChildMemberships(inChild);
childTargetPriors = targetData.getDistribution(child2Memberships, config);
splitCandidateChild = columnData.calcBestSplitClassification(child2Memberships, childTargetPriors, targetData, null);
assertNull(splitCandidateChild);
}
use of org.knime.base.node.mine.treeensemble2.data.TreeNominalColumnData in project knime-core by knime.
the class TreeNominalColumnDataTest method testCalcBestSplitClassificationMultiwayXGBoostMissingValueHandling.
/**
* This method tests the XGBoost missing value handling for classification in case of multiway splits.
*
* @throws Exception
*/
@Test
public void testCalcBestSplitClassificationMultiwayXGBoostMissingValueHandling() throws Exception {
final TreeEnsembleLearnerConfiguration config = createConfig(false);
config.setUseBinaryNominalSplits(false);
config.setMissingValueHandling(MissingValueHandling.XGBoost);
final TestDataGenerator dataGen = new TestDataGenerator(config);
final RandomData rd = config.createRandomData();
// test the case that there are no missing values in the training data
final String noMissingCSV = "a, a, a, b, b, b, b, c, c";
final String noMissingTarget = "A, B, B, C, C, C, B, A, B";
TreeNominalColumnData dataCol = dataGen.createNominalAttributeColumn(noMissingCSV, "noMissings", 0);
TreeTargetNominalColumnData targetCol = TestDataGenerator.createNominalTargetColumn(noMissingTarget);
DataMemberships dataMem = createMockDataMemberships(targetCol.getNrRows());
SplitCandidate split = dataCol.calcBestSplitClassification(dataMem, targetCol.getDistribution(dataMem, config), targetCol, rd);
assertNotNull("There is a possible split.", split);
assertEquals("Incorrect gain.", 0.216, split.getGainValue(), 1e-3);
assertThat(split, instanceOf(NominalMultiwaySplitCandidate.class));
NominalMultiwaySplitCandidate nomSplit = (NominalMultiwaySplitCandidate) split;
assertTrue("No missing values in the column.", nomSplit.getMissedRows().isEmpty());
TreeNodeNominalCondition[] conditions = nomSplit.getChildConditions();
assertEquals("Wrong number of child conditions.", 3, conditions.length);
assertEquals("Wrong value in child condition.", "a", conditions[0].getValue());
assertEquals("Wrong value in child condition.", "b", conditions[1].getValue());
assertEquals("Wrong value in child condition.", "c", conditions[2].getValue());
assertFalse("Missing values should be sent to the majority child (i.e. b)", conditions[0].acceptsMissings());
assertTrue("Missing values should be sent to the majority child (i.e. b)", conditions[1].acceptsMissings());
assertFalse("Missing values should be sent to the majority child (i.e. b)", conditions[2].acceptsMissings());
// test the case that there are missing values in the training data
final String missingCSV = "a, a, a, b, b, b, b, c, c, ?";
final String missingTarget = "A, B, B, C, C, C, B, A, B, C";
dataCol = dataGen.createNominalAttributeColumn(missingCSV, "missings", 0);
targetCol = TestDataGenerator.createNominalTargetColumn(missingTarget);
dataMem = createMockDataMemberships(targetCol.getNrRows());
split = dataCol.calcBestSplitClassification(dataMem, targetCol.getDistribution(dataMem, config), targetCol, rd);
assertNotNull("There is a possible split.", split);
assertEquals("Incorrect gain.", 0.2467, split.getGainValue(), 1e-3);
assertThat(split, instanceOf(NominalMultiwaySplitCandidate.class));
nomSplit = (NominalMultiwaySplitCandidate) split;
assertTrue("Split should handle missing values.", nomSplit.getMissedRows().isEmpty());
conditions = nomSplit.getChildConditions();
assertEquals("Wrong number of child conditions.", 3, conditions.length);
assertEquals("Wrong value in child condition.", "a", conditions[0].getValue());
assertEquals("Wrong value in child condition.", "b", conditions[1].getValue());
assertEquals("Wrong value in child condition.", "c", conditions[2].getValue());
assertFalse("Missing values should be sent to b", conditions[0].acceptsMissings());
assertTrue("Missing values should be sent to b", conditions[1].acceptsMissings());
assertFalse("Missing values should be sent to b", conditions[2].acceptsMissings());
}
use of org.knime.base.node.mine.treeensemble2.data.TreeNominalColumnData in project knime-core by knime.
the class TreeNominalColumnDataTest method testCalcBestSplitClassificationBinaryPCA.
/**
* Tests the method
* {@link TreeNominalColumnData#calcBestSplitClassification(DataMemberships, ClassificationPriors, TreeTargetNominalColumnData, RandomData)}
* using binary splits. In this test case the data has more than two classes and the used algorithm is therefore PCA
* based.
*
* @throws Exception
*/
@Test
public void testCalcBestSplitClassificationBinaryPCA() throws Exception {
TreeEnsembleLearnerConfiguration config = createConfig(false);
Pair<TreeNominalColumnData, TreeTargetNominalColumnData> pcaData = createPCATestData(config);
TreeNominalColumnData columnData = pcaData.getFirst();
TreeTargetNominalColumnData targetData = pcaData.getSecond();
TreeData treeData = createTreeData(pcaData);
assertEquals(SplitCriterion.Gini, config.getSplitCriterion());
double[] rowWeights = new double[targetData.getNrRows()];
Arrays.fill(rowWeights, 1.0);
IDataIndexManager indexManager = new DefaultDataIndexManager(treeData);
DataMemberships dataMemberships = new RootDataMemberships(rowWeights, treeData, indexManager);
ClassificationPriors priors = targetData.getDistribution(rowWeights, config);
SplitCandidate splitCandidate = columnData.calcBestSplitClassification(dataMemberships, priors, targetData, null);
assertNotNull(splitCandidate);
assertThat(splitCandidate, instanceOf(NominalBinarySplitCandidate.class));
assertTrue(splitCandidate.canColumnBeSplitFurther());
assertEquals(0.0659, splitCandidate.getGainValue(), 0.0001);
NominalBinarySplitCandidate binarySplitCandidate = (NominalBinarySplitCandidate) splitCandidate;
TreeNodeNominalBinaryCondition[] childConditions = binarySplitCandidate.getChildConditions();
assertEquals(2, childConditions.length);
assertArrayEquals(new String[] { "E" }, childConditions[0].getValues());
assertArrayEquals(new String[] { "E" }, childConditions[1].getValues());
assertEquals(SetLogic.IS_NOT_IN, childConditions[0].getSetLogic());
assertEquals(SetLogic.IS_IN, childConditions[1].getSetLogic());
}
use of org.knime.base.node.mine.treeensemble2.data.TreeNominalColumnData in project knime-core by knime.
the class TreeNominalColumnDataTest method testUpdateChildMemberships.
/**
* Tests the method
* {@link TreeNominalColumnData#updateChildMemberships(org.knime.base.node.mine.treeensemble2.model.TreeNodeCondition, DataMemberships)}
* .
*
* @throws Exception
*/
@Test
public void testUpdateChildMemberships() throws Exception {
// in this case it doesn't matter if we use regression or classification (as well as binary and multiway splits)
final TreeEnsembleLearnerConfiguration config = createConfig(true);
final TestDataGenerator dataGen = new TestDataGenerator(config);
final String dataCSV = "A, A, A, A, B, B, B, C, C, C, ?, ?";
TreeNominalColumnData col = dataGen.createNominalAttributeColumn(dataCSV, "test-col", 0);
final int[] indices = new int[12];
final double[] weights = new double[indices.length];
for (int i = 0; i < indices.length; i++) {
indices[i] = i;
weights[i] = 1.0;
}
final DataMemberships dataMem = new MockDataColMem(indices, indices, weights);
TreeNodeNominalBinaryCondition binCond = new TreeNodeNominalBinaryCondition(col.getMetaData(), BigInteger.valueOf(2), true, false);
BitSet expected = new BitSet(12);
BitSet inChild = col.updateChildMemberships(binCond, dataMem);
expected.set(4, 7);
assertEquals("The produced BitSet is incorrect.", expected, inChild);
binCond = new TreeNodeNominalBinaryCondition(col.getMetaData(), BigInteger.valueOf(2), true, true);
expected.clear();
expected.set(4, 7);
expected.set(10, 12);
inChild = col.updateChildMemberships(binCond, dataMem);
assertEquals("The produced BitSet is incorrect.", expected, inChild);
binCond = new TreeNodeNominalBinaryCondition(col.getMetaData(), BigInteger.valueOf(2), false, false);
expected.clear();
expected.set(0, 4);
expected.set(7, 10);
inChild = col.updateChildMemberships(binCond, dataMem);
assertEquals("The produced BitSet is incorrect.", expected, inChild);
binCond = new TreeNodeNominalBinaryCondition(col.getMetaData(), BigInteger.valueOf(2), false, true);
expected.clear();
expected.set(0, 4);
expected.set(7, 12);
inChild = col.updateChildMemberships(binCond, dataMem);
assertEquals("The produced BitSet is incorrect.", expected, inChild);
binCond = new TreeNodeNominalBinaryCondition(col.getMetaData(), BigInteger.valueOf(5), true, false);
expected.clear();
expected.set(0, 4);
expected.set(7, 10);
inChild = col.updateChildMemberships(binCond, dataMem);
assertEquals("The produced BitSet is incorrect.", expected, inChild);
binCond = new TreeNodeNominalBinaryCondition(col.getMetaData(), BigInteger.valueOf(5), true, true);
expected.clear();
expected.set(0, 4);
expected.set(7, 12);
inChild = col.updateChildMemberships(binCond, dataMem);
assertEquals("The produced BitSet is incorrect.", expected, inChild);
TreeNodeNominalCondition multiCond = new TreeNodeNominalCondition(col.getMetaData(), 0, false);
expected.clear();
expected.set(0, 4);
inChild = col.updateChildMemberships(multiCond, dataMem);
assertEquals("The produced BitSet is incorrect.", expected, inChild);
multiCond = new TreeNodeNominalCondition(col.getMetaData(), 0, true);
expected.clear();
expected.set(0, 4);
expected.set(10, 12);
inChild = col.updateChildMemberships(multiCond, dataMem);
assertEquals("The produced BitSet is incorrect.", expected, inChild);
multiCond = new TreeNodeNominalCondition(col.getMetaData(), 2, false);
expected.clear();
expected.set(7, 10);
inChild = col.updateChildMemberships(multiCond, dataMem);
assertEquals("The produced BitSet is incorrect.", expected, inChild);
multiCond = new TreeNodeNominalCondition(col.getMetaData(), 2, true);
expected.clear();
expected.set(7, 12);
inChild = col.updateChildMemberships(multiCond, dataMem);
assertEquals("The produced BitSet is incorrect.", expected, inChild);
}
Aggregations