Beispiel #1
0
  @Test
  public void testSingleLinkage() {
    Dataset<? extends Instance> dataset = FakeClustering.kumarData();
    assertEquals(6, dataset.size());
    Props pref = new Props();
    pref.put(AlgParams.LINKAGE, SingleLinkage.name);
    pref.put(AlgParams.CLUSTERING_TYPE, ClusteringType.ROWS_CLUSTERING);
    pref.put(PropType.PERFORMANCE, AlgParams.KEEP_PROXIMITY, true);
    HierarchicalResult result = subject.hierarchy(dataset, pref);
    Matrix similarityMatrix = result.getProximityMatrix();
    assertNotNull(similarityMatrix);
    assertEquals(similarityMatrix.rowsCount(), dataset.size());
    assertEquals(similarityMatrix.columnsCount(), dataset.size());
    System.out.println("kumar - single");
    DendroTreeData tree = result.getTreeData();
    tree.print();
    assertEquals(dataset.size(), tree.numLeaves());
    DendroNode root = tree.getRoot();
    assertEquals(0.21587033144922904, root.getHeight(), DELTA);

    int levels = tree.distinctHeights(1e-7);
    // TODO: in this example nodes #7 and #8 are on different level,
    // but their height is the same. should we consider those as different
    assertEquals(4, levels);
  }
Beispiel #2
0
 @Override
 public int getMappedIndex(int idx) {
   if (treeData == null) {
     throw new RuntimeException("Empty tree data");
   }
   return treeData.getMappedId(idx);
 }
Beispiel #3
0
 @Override
 public int treeLevels() {
   if (treeData != null) {
     return treeData.treeLevels();
   }
   return 0;
 }
Beispiel #4
0
 @Override
 public double cutTreeByLevel(int level) {
   DendroNode node = treeData.getRoot();
   double cut = findLevel(node, level);
   this.clustering = updateCutoff(cut);
   return cut;
 }
Beispiel #5
0
 private DendroNode getNode(int idx) {
   DendroNode node = treeData.getLeaf(idx);
   if (node == null) {
     node = new DTreeNode();
     node.setId(idx);
   }
   return node;
 }
Beispiel #6
0
 /**
  * TODO: this is hardly correct
  *
  * @return
  */
 @Override
 public double getMaxTreeHeight() {
   if (treeData == null) {
     LOG.info("constructing tree");
     constructTree();
   }
   return treeData.getRoot().getHeight();
 }
Beispiel #7
0
 /**
  * Return leaves mapping to indexes in dataset
  *
  * @return
  */
 @Override
 public int[] getMapping() {
   /* if (mapping == null && merges != null) {
    * updateMapping();
    * }
    *
    * return mapping; */
   if (treeData != null) {
     return treeData.getMapping();
   }
   return null;
 }
Beispiel #8
0
  private void constructTree() {
    if (merges == null) {
      throw new RuntimeException("merges empty!");
    }
    LOG.info("constructing tree, merge size:{}", merges.size());
    treeData = new DynamicTreeData();

    DendroNode[] nodes = new DendroNode[merges.size() + 1];

    DendroNode current = null;
    DendroNode prev = null;
    // for (Merge m : getMerges()) {

    Merge m;
    for (int i = merges.size() - 1; i >= 0; i--) {
      m = merges.get(i);
      current = new DTreeNode();
      // bottom level
      if (prev == null) {
        prev = getNode(m.remainingCluster());
      }

      current.setLeft(prev);
      current.setRight(getNode(m.mergedCluster()));
      current.setHeight(m.similarity());
      prev = current;
      //  System.out.println("merge: " + m.mergedCluster() + " remain: " + m.remainingCluster() + "
      // similarity = " + m.similarity());
    }
    numNodes = 0;
    // number leaves, so that we can compute it's position
    numberLeaves(current);
    treeData.updatePositions(current);

    treeData.setRoot(current);
    treeData.setLeaves(nodes);
    LOG.info("max tree height: {}", current.getHeight());
  }
Beispiel #9
0
 private void subtreeToCluster(DendroNode node, Cluster c, int[] assign) {
   if (node.isLeaf()) {
     if (treeData.containsClusters()) {
       DClusterLeaf<E> leaf = (DClusterLeaf) node;
       for (E instance : leaf.getInstances()) {
         c.add(instance);
         assign[instance.getIndex()] = c.getClusterId();
       }
     } else {
       c.add(((DendroLeaf) node).getData());
       assign[node.getId()] = c.getClusterId();
     }
   } else {
     subtreeToCluster(node.getLeft(), c, assign);
     subtreeToCluster(node.getRight(), c, assign);
   }
 }
Beispiel #10
0
  @Test
  public void testSingleLinkageSchool() {
    Dataset<? extends Instance> dataset = FakeClustering.schoolData();
    assertEquals(17, dataset.size());
    Props pref = new Props();
    pref.put(AlgParams.LINKAGE, SingleLinkage.name);
    pref.put(AlgParams.CLUSTERING_TYPE, ClusteringType.ROWS_CLUSTERING);
    HierarchicalResult result = subject.hierarchy(dataset, pref);
    System.out.println("school - single");
    DendroTreeData tree = result.getTreeData();
    tree.print();
    assertEquals(dataset.size(), tree.numLeaves());
    DendroNode root = tree.getRoot();
    assertEquals(32.542734980330046, root.getHeight(), DELTA);
    assertEquals(2 * dataset.size() - 1, tree.numNodes());

    assertEquals(16, tree.distinctHeights());
    assertEquals(8, tree.treeLevels());
  }
Beispiel #11
0
 @Override
 public Clustering updateCutoff(double cutoff) {
   this.cutoff = cutoff;
   int[] assign = new int[dataset.size()];
   int estClusters = (int) Math.sqrt(dataset.size());
   colorGenerator.reset();
   num = 0; // human readable
   Clustering clusters = new ClusterList(estClusters);
   DendroNode root = treeData.getRoot();
   if (root != null) {
     checkCutoff(root, cutoff, clusters, assign);
     if (clusters.size() > 0) {
       mapping = assign;
     } else {
       LOG.info("failed to cutoff dendrogram, cut = {}", cutoff);
     }
   }
   // add input dataset to clustering lookup
   if (noise != null) {
     Cluster clust = new BaseCluster<>(noise.size());
     clust.setColor(colorGenerator.next());
     clust.setClusterId(num++);
     clust.setParent(getDataset());
     clust.setName("Noise");
     clust.setAttributes(getDataset().getAttributes());
     for (Instance ins : noise) {
       clust.add(ins);
       mapping[ins.getIndex()] = num - 1;
     }
     clusters.add(clust);
   }
   clusters.lookupAdd(dataset);
   if (dendroMapping != null) {
     clusters.lookupAdd(dendroMapping);
   }
   clusters.lookupAdd(this);
   return clusters;
 }
Beispiel #12
0
 private void checkCutoff(DendroNode node, double cutoff, Clustering clusters, int[] assign) {
   if (node.isLeaf()) {
     if (treeData.containsClusters()) {
       DClusterLeaf<E> leaf = (DClusterLeaf) node;
       Cluster clust = makeCluster(clusters);
       for (E instance : leaf.getInstances()) {
         clust.add(instance);
         assign[instance.getIndex()] = clust.getClusterId();
       }
     }
     return;
   }
   if (node.getHeight() == cutoff) {
     // both branches goes to the same cluster
     Cluster clust = makeCluster(clusters);
     subtreeToCluster(node, clust, assign);
   } else if (node.getLeft().getHeight() < cutoff || node.getRight().getHeight() < cutoff) {
     Cluster clust;
     if (node.getLeft().getHeight() < cutoff && node.getRight().getHeight() < cutoff) {
       clust = makeCluster(clusters);
       subtreeToCluster(node.getLeft(), clust, assign);
       clust = makeCluster(clusters);
       subtreeToCluster(node.getRight(), clust, assign);
     } else if (node.getRight().getHeight() < cutoff) {
       clust = makeCluster(clusters);
       subtreeToCluster(node.getRight(), clust, assign);
       checkCutoff(node.getLeft(), cutoff, clusters, assign);
     } else if (node.getLeft().getHeight() < cutoff) {
       clust = makeCluster(clusters);
       subtreeToCluster(node.getLeft(), clust, assign);
       checkCutoff(node.getRight(), cutoff, clusters, assign);
     }
   } else {
     checkCutoff(node.getLeft(), cutoff, clusters, assign);
     checkCutoff(node.getRight(), cutoff, clusters, assign);
   }
 }
Beispiel #13
0
  @Test
  public void testInverseSorting() {
    Dataset<? extends Instance> dataset = FakeClustering.kumarData();
    assertEquals(6, dataset.size());
    Props pref = new Props();
    pref.put(AlgParams.LINKAGE, SingleLinkage.name);
    pref.put(AlgParams.CLUSTERING_TYPE, ClusteringType.ROWS_CLUSTERING);
    // inverse ordering
    pref.put(AlgParams.SMALLEST_FIRST, false);
    HierarchicalResult result = subject.hierarchy(dataset, pref);
    System.out.println("kumar - inverse");
    DendroTreeData tree = result.getTreeData();
    tree.print();
    assertEquals(dataset.size(), tree.numLeaves());
    DendroNode root = tree.getRoot();
    assertEquals(0.10198039027185574, root.getHeight(), DELTA);

    assertEquals(5, tree.distinctHeights());
    assertEquals(4, tree.treeLevels());
  }
Beispiel #14
0
 @Override
 public void setTreeData(DendroTreeData treeData) {
   this.treeData = treeData;
   treeData.updatePositions(treeData.getRoot());
 }
Beispiel #15
0
 @Override
 public double getHeightByLevel(int level) {
   return findLevelHeight(treeData.getRoot(), level);
 }