def test_createDistanceGraph_severalSamplesInClusters_4D(self):
d = 4
c1 = Cluster([(1.0, 7.0, 0.0, 0.0), (3.0, 7.0, 0.0, 0.0),
(1.0, 5.0, 0.0, 0.0), (3.0, 5.0, 0.0, 0.0)], d)
c3 = Cluster([(4.0, 7.0, 0.0, 0.0), (6.0, 5.0, 0.0, 0.0),
(6.0, 7.0, 0.0, 0.0), (4.0, 5.0, 0.0, 0.0)], d)
c2 = Cluster([(1.0, 3.0, 0.0, 0.0), (3.0, 3.0, 0.0, 0.0),
(1.0, 1.0, 0.0, 0.0), (3.0, 1.0, 0.0, 0.0)], d)
c4 = Cluster([(4.0, 3.0, 0.0, 0.0), (4.0, 1.0, 0.0, 0.0),
(6.0, 1.0, 0.0, 0.0), (6.0, 3.0, 0.0, 0.0)], d)
clusters = ClusterContainer([c1, c2, c3, c4], d)
g = createDistanceGraph(clusters.getClusters())
self.assertEquals(
g.get_edge_data(c1, c2)['weight'], 4.0, "la distancia debe ser 4")
self.assertEquals(
g.get_edge_data(c1, c3)['weight'], 3.0, "la distancia debe ser 3")
self.assertEquals(
g.get_edge_data(c1, c4)['weight'], 5.0, "la distancia debe ser 5")
self.assertEquals(
g.get_edge_data(c2, c3)['weight'], 5.0, "la distancia debe ser 5")
self.assertEquals(
g.get_edge_data(c2, c4)['weight'], 3.0, "la distancia debe ser 3")
self.assertEquals(
g.get_edge_data(c3, c4)['weight'], 4.0, "la distancia debe ser 4")
"minimumdistance: escuentra la arista de menor peso en el grafo de distancia"
def test_createDistanceGraph_severalSamplesInClusters_3D(self):
d = 3
c1 = Cluster([(1.0, 7.0, 0.0), (3.0, 7.0, 0.0), (1.0, 5.0, 0.0),
(3.0, 5.0, 0.0)], d)
c3 = Cluster([(4.0, 7.0, 0.0), (6.0, 5.0, 0.0), (6.0, 7.0, 0.0),
(4.0, 5.0, 0.0)], d)
c2 = Cluster([(1.0, 3.0, 0.0), (3.0, 3.0, 0.0), (1.0, 1.0, 0.0),
(3.0, 1.0, 0.0)], d)
c4 = Cluster([(4.0, 3.0, 0.0), (4.0, 1.0, 0.0), (6.0, 1.0, 0.0),
(6.0, 3.0, 0.0)], d)
clusters = ClusterContainer([c1, c2, c3, c4], d)
g = createDistanceGraph(clusters.getClusters())
self.assertEquals(
g.get_edge_data(c1, c2)['weight'], 4.0, "la distancia debe ser 4")
self.assertEquals(
g.get_edge_data(c1, c3)['weight'], 3.0, "la distancia debe ser 3")
self.assertEquals(
g.get_edge_data(c1, c4)['weight'], 5.0, "la distancia debe ser 5")
self.assertEquals(
g.get_edge_data(c2, c3)['weight'], 5.0, "la distancia debe ser 5")
self.assertEquals(
g.get_edge_data(c2, c4)['weight'], 3.0, "la distancia debe ser 3")
self.assertEquals(
g.get_edge_data(c3, c4)['weight'], 4.0, "la distancia debe ser 4")
def test_equalsTest_sameInstance_2D(self):
d2 = 2
d3 = 3
s1 = Sample((0.0,0.0))
s2 = Sample((1.0,0.0))
s3 = Sample((2.0,0.0))
s4 = Sample((3.0,0.0))
s5 = Sample((3.0,1.0))
s6 = Sample((0.0,0.0,0.0))
c1 = Cluster([s1,s2,s3],d2)
c2 = Cluster([s4],d2)
c3 = Cluster([s5],d2)
c4 = Cluster([s6],d3)
container1 = ClusterContainer([c1,c2],d2)
container2 = ClusterContainer([c1,c2],d2)
container3 = ClusterContainer([c1,c3],d2)
container4 = ClusterContainer([c3],d2)
container5 = c3
container6 = ClusterContainer([c4],d3)
self.assertEquals(container1, container2, "los container son iguales")
self.assertNotEquals(container1,container3, "los container no son iguales")
self.assertNotEquals(container1,container4, "los container no son iguales")
self.assertNotEquals(container1,container5, "container 5 no es un container")
self.assertNotEquals(container1,container6, "container 6 es una dimension diferente")
def test_containsOutliers5D(self):
d = 5
cluster_A = Cluster([(0.0, 3.0, 0.0, 2.0, 0.0),
(0.0, 4.0, 0.0, 2.0, 0.0),
(0.0, 4.0, 0.0, 1.0, 0.0),
(0.0, 3.0, 0.0, 1.0, 0.0)], d)
cluster_B = Cluster([(0.0, 3.0, 0.0, 5.0, 0.0),
(0.0, 5.0, 0.0, 5.0, 0.0),
(0.0, 4.0, 0.0, 6.0, 0.0)], d)
samples = SampleContainer([(0.0, 7.0, 0.0, 5.0, 0.0),
(0.0, 7.0, 0.0, 4.0, 0.0)], d)
resul = containsOutlier(mergeClusters(cluster_A, cluster_B), samples)
self.assertEqual(
False, resul,
"Dos clusters deberian ser mergeables si forman una componente convexa sin outliers en dimension %s"
% (d))
samples = SampleContainer([(0.0, 4.0, 0.0, 4.0, 0.0),
(0.0, 3.0, 0.0, 4.0, 0.0),
(0.0, 5.0, 0.0, 4.0, 0.0)], d)
resul = containsOutlier(mergeClusters(cluster_A, cluster_B), samples)
self.assertEqual(
True, resul,
"Dos clusters no deberian ser mergeables si forman una componente convexa con outliers %s"
% (d))
def test_distance4D(self):
d = 4
c1 = Cluster([(2.0, 5.0, 0.0, 0.0), (3.0, 5.0, 0.0, 0.0),
(2.0, 4.0, 0.0, 0.0), (3.0, 4.0, 0.0, 0.0)], d)
c2 = Cluster([(2.0, 3.5, 0.0, 0.0), (3.0, 3.5, 0.0, 0.0),
(2.0, 2.5, 0.0, 0.0), (3.0, 2.5, 0.0, 0.0)], d)
self.assertEquals(distance(c1, c2), 1.5,
"la distancia entre c1 y c2 es 1.5")
def test_merge_2D(self):
d = 2
cluster_A = Cluster([(0.0, 0.0), (1.0, 1.0)], d)
cluster_B = Cluster([(2.0, 2.0), (3.0, 3.0)], d)
c_test = Cluster([(0.0, 0.0), (1.0, 1.0), (2.0, 2.0), (3.0, 3.0)], d)
c = mergeClusters(cluster_A, cluster_B)
self.assertEquals(c_test, c, "los cluster deben ser iguales")
self.assertNotEquals(cluster_A, c, "los clusters no son iguales")
self.assertNotEquals(cluster_B, c, "los clusters no son iguales")
def testisMergeableEmptyOutliers(self):
d = 2
cluster_A = Cluster([(0.0, 2.0), (0.0, 4.0)], d)
cluster_B = Cluster([(4.0, 2.0), (4.0, 4.0)], d)
samples = SampleContainer([], d)
resul = containsOutlier(mergeClusters(cluster_A, cluster_B), samples)
self.assertEqual(
False, resul,
"Dos clusters deberian ser mergeables si no hay otras muestras")
def test_minimumDistance_trivial_4d(self):
d = 4
c1 = Cluster([(0.0, 0.0, 0.0, 0.0)], d)
c2 = Cluster([(1.0, 0.0, 0.0, 0.0)], d)
clusters = ClusterContainer([c1, c2], d)
g = createDistanceGraph(clusters.getClusters())
(u, v) = minimumEdge(g)
self.assertEquals(g[u][v]['weight'], 1.0,
"la minima arista tiene peso 1")
def test_minimunDistanceOnlyOneSamplesForCluster_4D(self):
d = 4
c1 = Cluster([(2.0, 6.0, 0.0, 0.0)], d)
c2 = Cluster([(2.0, 2.0, 0.0, 0.0)], d)
c3 = Cluster([(5.0, 6.0, 0.0, 0.0)], d)
c4 = Cluster([(5.0, 2.0, 0.0, 0.0)], d)
clusters = ClusterContainer([c1, c2, c3, c4], d)
g = createDistanceGraph(clusters.getClusters())
(u, v) = minimumEdge(g)
self.assertEquals(g[u][v]['weight'], 3.0,
"la minima arista tiene peso 3")
def test_minimumDistance_severalSamplesInClusters_2D(self):
d = 2
c1 = Cluster([(1.0, 7.0), (3.0, 7.0), (1.0, 5.0), (3.0, 5.0)], d)
c2 = Cluster([(1.0, 3.0), (3.0, 3.0), (1.0, 1.0), (3.0, 1.0)], d)
c3 = Cluster([(4.0, 7.0), (6.0, 5.0), (6.0, 7.0), (4.0, 5.0)], d)
c4 = Cluster([(4.0, 3.0), (4.0, 1.0), (6.0, 1.0), (6.0, 3.0)], d)
clusters = ClusterContainer([c1, c2, c3, c4], d)
g = createDistanceGraph(clusters.getClusters())
(u, v) = minimumEdge(g)
self.assertEquals(g[u][v]['weight'], 3.0,
"la minima arista tiene peso 3")
def test_onlyOneOutlier_3D(self):
d = 3
classA = SampleContainer([(0.0, 0.0, 0.0), (0.0, 1.0, 0.0),
(0.0, 2.0, 0.0), (0.0, 3.0, 0.0)], d)
classB = SampleContainer([(0.0, 1.5, 0.0)], d)
clusters = createClusters(classA, classB)
clusters_test = ClusterContainer([
Cluster([(0.0, 2.0, 0.0), (0.0, 3.0, 0.0)], d),
Cluster([(0.0, 0.0, 0.0), (0.0, 1.0, 0.0)], d)
], d)
self.assertEquals(
clusters, clusters_test,
"las muestras mergeables deben estar en el mismo cluster")
def test_createClusters2_severalOutliers2D(self):
d = 2
s1, s2, s3, s4, s5 = (3.0, 7.0), (3.0, 6.0), (10.0, 7.0), (10.0,
6.0), (6.5,
6.5)
samplesA = SampleContainer([s1, s2, s3, s4, s5], d)
samplesB = SampleContainer([(6.0, 7.0), (6.0, 6.0), (7.0, 6.0),
(7.0, 7.0), (6.0, 6.5), (7.0, 6.5)], d)
c1 = Cluster([s1, s2], d)
c2 = Cluster([s4, s3], d)
c3 = Cluster([s5], d)
clusters = createClusters(samplesA, samplesB)
for spl in samplesA.getSamples():
self.assertTrue(spl in clusters.getSamples().getSamples())
def test_onlyOneSampleForCluster_2D(self):
d = 2
s0_1, s0_2, s0_3, s0_4 = (0.0, 2.0), (0.0, 4.0), (0.0, 6.0), (0.0, 8.0)
s1_1, s1_2, s1_3, s1_4 = (0.0, 1.0), (0.0, 3.0), (0.0, 5.0), (0.0, 7.0)
classA = SampleContainer([s1_1, s1_2, s1_3, s1_4], d)
classB = SampleContainer([s0_1, s0_2, s0_3, s0_4], d)
clusters = createClusters(classA, classB)
clusters_test = ClusterContainer([
Cluster([s1_1], d),
Cluster([s1_2], d),
Cluster([s1_3], d),
Cluster([s1_4], d)
], d)
self.assertEquals(clusters, clusters_test,
"debe generarce un cluster para cada muestra")
def test_defineHyperplane_severalSamples_4D(self):
d = 4
cluster = Cluster([(0.0, 6.5, 4.5, 0.0), (0.0, 8.0, 5.0, 0.0),
(0.0, 9.0, 5.0, 0.0), (0.0, 7.0, 3.0, 0.0),
(0.0, 8.0, 4.0, 0.0), (0.0, 7.0, 5.0, 0.0)], d)
group = Group([(0.0, 5.0, 4.0, 0.0), (0.0, 5.0, 5.0, 0.0),
(0.0, 6.0, 5.0, 0.0), (0.0, 5.0, 6.0, 0.0),
(0.0, 4.0, 6.0, 0.0)], d)
hyperplane = defineHyperplane(group, cluster)
self.assertEquals(hyperplane.getCoefficient(0), 0.0,
"0.0 debe multiplicar la primera innognita")
self.assertTrue(
2.0 < hyperplane.getCoefficient(1)
and 2.1 > hyperplane.getCoefficient(1),
"2 debe multiplicar la primer incognita")
self.assertTrue(
-2.0 < hyperplane.getCoefficient(2)
and -1.9 > hyperplane.getCoefficient(2),
"-2 debe multiplicar la segunda incognita")
self.assertEquals(hyperplane.getCoefficient(3), 0.0,
"0.0 debe multiplicar la cuarta innognita")
self.assertTrue(
3.0 < hyperplane.getIntercept()
and 3.1 > hyperplane.getIntercept(), "alfa debe ser 3")
def test_createClusters_severalOutliers2D(self):
d = 2
s1, s2, s3, s4, s5 = (3.0, 7.0), (3.0, 6.0), (10.0, 7.0), (10.0,
6.0), (6.5,
6.5)
samplesA = SampleContainer([s1, s2, s3, s4, s5], d)
samplesB = SampleContainer([(6.0, 7.0), (6.0, 6.0), (7.0, 6.0),
(7.0, 7.0), (6.0, 6.5), (7.0, 6.5)], d)
c1 = Cluster([s1, s2], d)
c2 = Cluster([s4, s3], d)
c3 = Cluster([s5], d)
container_test = ClusterContainer([c1, c2, c3], d)
container = createClusters(samplesA, samplesB)
self.assertEquals(
container, container_test,
"Deben definirse los clusters: [s1,s2],[s3,s4],[s5]")
def test_containsOutliers2D(self):
d = 2
cluster_A = Cluster([(0.0, 2.0), (0.0, 4.0)], d)
cluster_B = Cluster([(4.0, 2.0), (4.0, 4.0)], d)
samples = SampleContainer([(6.0, 3.0)], d)
resul = containsOutlier(mergeClusters(cluster_A, cluster_B), samples)
self.assertEqual(
False, resul,
"Dos clusters deberian ser mergeables si forman una componente convexa sin outliers"
)
samples = SampleContainer([(2.3, 3.0)], d)
resul = containsOutlier(mergeClusters(cluster_A, cluster_B), samples)
self.assertEqual(
True, resul,
"Dos clusters no deberian ser mergeables si forman una componente convexa con outliers"
)
pass
def test_equalsTest_differentInstancesOfTheSameData2D(self):
d = 2
d3 = 3
c1 = ClusterContainer([Cluster([(0.0,1.0),(1.0,1.0),(2.0,1.0)],d), Cluster([(2.6,3.4)],d)],d)
c2 = ClusterContainer([Cluster([(0.0,1.0),(1.0,1.0),(2.0,1.0)],d), Cluster([(2.6,3.4)],d)],d)
c3 = ClusterContainer([Cluster([(0.0,1.0),(1.0,1.0),(2.0,1.0)],d), Cluster([(2.7,3.4)],d)],d)
c4 = ClusterContainer([Cluster([(2.6,3.4)],d)],d)
c5 = Cluster([(2.6,3.4)],d)
c6 = ClusterContainer([Cluster([(0.0,1.0,0.0),(1.0,1.0,0.0),(2.0,1.0,0.0)],d), Cluster([(2.6,3.4,0.0)],d3)],d3)
self.assertEquals(c1,c2,"Los dos clusters container son iguales")
self.assertNotEquals(c1,c3, "los clusters container no son iguales")
self.assertNotEquals(c1, c4, "Los clusters container no son iguales")
self.assertNotEquals(c1, c5, "c5 no es un cluster container")
self.assertNotEquals(c1, c6, "los cluster container son de dimension diferente")
def test_createDistanceGraph_4D(self):
d = 4
c1 = Cluster([(2.0, 6.0, 0.0, 0.0)], d)
c2 = Cluster([(2.0, 2.0, 0.0, 0.0)], d)
c3 = Cluster([(5.0, 6.0, 0.0, 0.0)], d)
c4 = Cluster([(5.0, 2.0, 0.0, 0.0)], d)
clusters = ClusterContainer([c1, c2, c3, c4], d)
g = createDistanceGraph(clusters.getClusters())
self.assertEquals(
g.get_edge_data(c1, c2)['weight'], 4.0, "la distancia debe ser 4")
self.assertEquals(
g.get_edge_data(c1, c3)['weight'], 3.0, "la distancia debe ser 3")
self.assertEquals(
g.get_edge_data(c1, c4)['weight'], 5.0, "la distancia debe ser 5")
self.assertEquals(
g.get_edge_data(c2, c3)['weight'], 5.0, "la distancia debe ser 5")
self.assertEquals(
g.get_edge_data(c2, c4)['weight'], 3.0, "la distancia debe ser 3")
self.assertEquals(
g.get_edge_data(c3, c4)['weight'], 4.0, "la distancia debe ser 4")
def test_defineHyperplane_trivial_2D(self):
d = 2
cluster = Cluster([(7.0, 4.0)], d)
group = Group([(5.0, 4.0)], d)
hyperplane = defineHyperplane(group, cluster)
self.assertTrue(
0.99999995001 > hyperplane.getCoefficient(0)
and 0.99999995000 < hyperplane.getCoefficient(0),
"0.99999995001 debe multiplicar la primer incognita")
self.assertEquals(0.0, hyperplane.getCoefficient(1),
"0.0 debe multiplicar la segunda incognita")
self.assertTrue(
5.99999970006 > hyperplane.getIntercept()
and 5.99999970005 < hyperplane.getIntercept(),
"alfa debe ser 5.99999970006")
def test_createClusters_allSamplesInTheSameCluster_2D(self):
d = 2
s0_1, s0_2, s0_3 = Sample((3.0, 3.0)), Sample((4.0, 4.0)), Sample(
(3.0, 4.0))
s1_1, s1_2, s1_3, s1_4, s1_5, s1_6 = Sample((0.0, 1.0)), Sample(
(0.0, 2.0)), Sample((0.0, 3.0)), Sample((1.0, 0.0)), Sample(
(1.0, 1.0)), Sample((1.0, 2.0))
class0 = SampleContainer([s0_1, s0_2, s0_3], d)
class1 = SampleContainer([s1_1, s1_2, s1_3, s1_4, s1_5, s1_6], d)
clusters_test = ClusterContainer(
[Cluster([s1_1, s1_2, s1_3, s1_4, s1_5, s1_6], d)], d)
clusters = createClusters(class1, class0)
self.assertEquals(
clusters_test, clusters,
"todas las muestras deben estar en un unico cluster")
def test_createRegions_trivial4D(self):
d = 4
groups = GroupContainer(d)
groups.addSamples(1, [Sample((5.0, 4.0, 0.0, 0.0))])
clusters = ClusterContainer([Cluster([(7.0, 4.0, 0.0, 0.0)], d)], d)
regions = createRegions(groups, clusters)
hiperplanes = regions[0].getHyperplanes().pop()
self.assertTrue(
0.999999950215 < hiperplanes.getCoefficient(0)
and 0.999999950216 > hiperplanes.getCoefficient(0),
"0.99999995001 debe multiplicar la primer incognita")
self.assertEquals(0.0, hiperplanes.getCoefficient(1),
"0.0 debe multiplicar la segunda incognita")
self.assertTrue(
5.9999997013 > hiperplanes.getIntercept()
and 5.9999997012 < hiperplanes.getIntercept(),
"alfa debe ser 5.9999997013")
def test_defineHyperplane_trivial_3D(self):
d = 3
cluster = Cluster([(7.0, 4.0, 0.0)], d)
group = Group([(5.0, 4.0, 0.0)], d)
hyperplane = defineHyperplane(group, cluster)
self.assertTrue(
0.99999995001 < hyperplane.getCoefficient(0)
and 0.99999995002 > hyperplane.getCoefficient(0),
"0.99999995001 debe multiplicar la primer incognita")
self.assertEqual(0.0, hyperplane.getCoefficient(1),
"0.0 debe multiplicar la segunda incognita")
self.assertEqual(0.0, hyperplane.getCoefficient(2),
"cero debe multiplicar a la tercera incognita")
self.assertTrue(
5.99999970006 < hyperplane.getIntercept()
and 5.99999970007 > hyperplane.getIntercept(),
"alfa debe ser 5.99999970007")
def test_defineHyperplane_severalSamples_2D(self):
d = 2
cluster = Cluster([(6.5, 4.5), (8.0, 5.0), (9.0, 5.0), (7.0, 3.0),
(8.0, 4.0), (7.0, 5.0)], d)
group = Group([(5.0, 4.0), (5.0, 5.0), (6.0, 5.0), (5.0, 6.0),
(4.0, 6.0)], d)
hyperplane = defineHyperplane(group, cluster)
self.assertTrue(
2.0 < hyperplane.getCoefficient(0)
and 2.1 > hyperplane.getCoefficient(0),
"2 debe multiplicar la primer incognita")
self.assertTrue(
-2.0 < hyperplane.getCoefficient(1)
and -1.9 > hyperplane.getCoefficient(1),
"-2 debe multiplicar la segunda incognita")
self.assertTrue(
3.0 < hyperplane.getIntercept()
and 3.1 > hyperplane.getIntercept(), "alfa debe ser 3")
def createDefaultClusters(samples):
d = samples.getDimension()
return ClusterContainer(
map(lambda spl: Cluster([spl], d), samples.getSamples()), d)
def removeOutliers(clusters, outliers):
return ClusterContainer(
map(
lambda clstr: Cluster(clstr.getSamples() - outliers.getSamples(),
clstr.getDimension()),
clusters.getClusters()), clusters.getDimension())
