def test_classify_twoSquarePoliedrom(self):
d = 2
k = 2
t0 = "blue"
t1 = "red"
sample_blue1 = Sample((8.0, 8.0))
sample_blue2 = Sample((2.0, 2.0))
sample_red = Sample((5.0, 5.0))
h1 = Hyperplane({0: 1, 1: 0}, 4)
h2 = Hyperplane({0: -1, 1: 0}, 0)
h3 = Hyperplane({0: 0, 1: 1}, 4)
h4 = Hyperplane({0: 1, 1: -1}, 0)
h5 = Hyperplane({0: 1, 1: 0}, 10)
h6 = Hyperplane({0: -1, 1: 0}, -6)
h7 = Hyperplane({0: 0, 1: 1}, 10)
h8 = Hyperplane({0: 0, 1: -1}, -6)
classifier = Classifier([], [], t0, t1, d, k)
classifier.regions = [
Region([h1, h2, h3, h4], d),
Region([h5, h6, h7, h8], d)
]
self.assertEquals(t1, classifier.classify(sample_blue1),
"la muestra debe ser azul")
self.assertEquals(t1, classifier.classify(sample_blue2),
"la muestra debe ser azul")
self.assertEquals(t0, classifier.classify(sample_red),
"la muestra debe ser roja")
def createDisplaceSample(samples,d):
def minValuesSample(a,b):
s = []
for f in range(0,d):
if a.getFeature(f) > b.getFeature(f):
s.append(b.getFeature(f))
else:
s.append(a.getFeature(f))
return tuple(s)
minValues = reduce(lambda a,b: Sample(minValuesSample(a, b)), samples.getSamples())
return Sample(tuple(map(lambda n: abs(minValues.getFeature(n)), range(d))))
def test_Classify_trivial(self):
d = 2
k = 1
t0 = "blue"
t1 = "red"
sample_blue = Sample((2.0, 0.0))
sample_red = Sample((6.0, 0.0))
hyperplane = Hyperplane({0: 4, 1: 0}, 16)
classifier = Classifier([], [], t0, t1, d, k)
classifier.regions = [Region([hyperplane], d)]
self.assertEquals(t1, classifier.classify(sample_blue),
"la muestra debe ser azul")
self.assertEquals(t0, classifier.classify(sample_red),
"la muestra debe ser roja")
def test_createClusters2_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 = createClusters2(class1, class0)
for spl in class1.getSamples():
self.assertTrue(spl in clusters.getSamples().getSamples())
def test_classify_Polytope(self):
d = 2
k = 2
t0 = "blue"
t1 = "red"
sample_blue = Sample((-5.0, -5.0))
sample_red = Sample((5.0, 5.0))
h1 = Hyperplane({0: 1, 1: 2}, 5)
h2 = Hyperplane({0: 1, 1: 0.5}, 5)
classifier = Classifier([], [], t0, t1, d, k)
classifier.regions = [Region([h1, h2], d)]
self.assertEquals(t1, classifier.classify(sample_blue),
"la muestra debe ser azul")
self.assertEquals(t0, classifier.classify(sample_red),
"la muestra debe ser roja")
def test_createClusters2_DefineClusterNoneOutlierOnlyOneSample_2D(self):
d = 2
sA = Sample((0.0, 0.0))
classA = SampleContainer([sA], d)
classB = SampleContainer([(4.0, 0.0)], d)
clusters = createClusters2(classA, classB)
for spl in classA.getSamples():
self.assertTrue(spl in clusters.getSamples().getSamples())
def test_Classify_squarePolyedrom(self):
d = 2
k = 1
t0 = "blue"
t1 = "red"
sample_blue = Sample((2.0, 2.0))
sample_red = Sample((6.0, 0.0))
h1 = Hyperplane({0: 1, 1: 0}, 4)
h2 = Hyperplane({0: -1, 1: 0}, 0)
h3 = Hyperplane({0: 0, 1: 1}, 4)
h4 = Hyperplane({0: 1, 1: -1}, 0)
classifier = Classifier([], [], t0, t1, d, k)
classifier.regions = [Region([h1, h2, h3, h4], d)]
self.assertEquals(t1, classifier.classify(sample_blue),
"la muestra debe ser azul")
self.assertEquals(t0, classifier.classify(sample_red),
"la muestra debe ser roja")
def test_Classify_irregularPolyhedron(self):
d = 2
k = 1
t0 = "blue"
t1 = "red"
sample_blue = Sample((0.0, 0.0))
sample_red = Sample((20.0, 20.0))
h1 = Hyperplane({0: 1, 1: 1}, 10)
h2 = Hyperplane({0: -10, 1: -1}, 10)
h3 = Hyperplane({0: 4, 1: -1}, 50)
h4 = Hyperplane({0: 1, 1: -1}, 10)
classifier = Classifier([], [], t0, t1, d, k)
classifier.regions = [Region([h1, h2, h3, h4], d)]
self.assertEquals(t1, classifier.classify(sample_blue),
"la muestra debe ser azul")
self.assertEquals(t0, classifier.classify(sample_red),
"la muestra debe ser roja")
def test_DefineClusterNoneOutlierOnlyOneSample_4D(self):
d = 4
sA = Sample((0.0, 0.0, 0.0, 0.0))
classA = SampleContainer([sA], d)
classB = SampleContainer([(0.0, 4.0, 0.0, 0.0)], d)
clusters = createClusters(classA, classB)
self.assertEquals(clusters.getSize(), 1,
"solo debe generarce un cluster")
self.assertTrue(sA in clusters.getClusters().pop().getSamples())
def test_createScrollTuple(self):
d = 2
samples = SampleContainer([(2.0, 3.0), (-2.0, 3.0), (-2.0, -2.0),
(3.0, -2.0), (-4.0, 4.0), (-4.0, -2.0),
(1.0, -3.0)], d)
gb = createScrollSample(samples, d)
for i in range(d):
print(gb.getFeature(i))
self.assertEquals(Sample((4.0, 3.0)), createScrollSample(samples, d))
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_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_classify_twoPolytope(self):
d = 2
k = 2
t0 = "blue"
t1 = "red"
sample_blue1 = Sample((-10.0, -5.0))
sample_blue2 = Sample((40.0, 20.0))
sample_red = Sample((5.0, 5.0))
h1 = Hyperplane({0: 1, 1: 2}, 5)
h2 = Hyperplane({0: 1, 1: 0.5}, 5)
h3 = Hyperplane({0: -1, 1: -2}, -30)
h4 = Hyperplane({0: -1, 1: -0.5}, -30)
classifier = Classifier([], [], t0, t1, d, k)
classifier.regions = [Region([h1, h2], d), Region([h3, h4], d)]
self.assertEquals(t1, classifier.classify(sample_blue1),
"la muestra debe ser azul")
self.assertEquals(t1, classifier.classify(sample_blue2),
"la muestra debe ser azul")
self.assertEquals(t0, classifier.classify(sample_red),
"la muestra debe ser roja")
def test_displace(self):
def isInFirstQuandrant(sample):
for i in range(sample.getDimension()):
if sample.getFeature(i) < 0:
return False
return True
d = 2
samples = SampleContainer([(2.0, 3.0), (-2.0, 3.0), (-2.0, -2.0),
(3.0, -2.0), (-4.0, 4.0), (-4.0, -2.0),
(1.0, -3.0)], d)
scroll = Sample((4.0, 3.0))
test = displace(samples, scroll)
for sample in test.getSamples():
self.assertTrue(isInFirstQuandrant(sample))
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 __init__(self, s,d):
'''
un sampleContainer contiene un conjunto de muestras y la dimension de cada una. Todas deben tener la misma dimension
'''
self.__data = set(map(lambda spl: spl if isinstance(spl,Sample) else Sample(spl),s))
self.__dimension = d
def __rowConfuseMatrix(self, clasifier, sample, color):
r1, r2 = 0, 0
for i in sample:
if(clasifier.classify(Sample(i)).__eq__(color)): r1+=1
else: r2+=1
return r1, r2
def sampleSum(s1,s2,d):
return Sample(tuple(map(lambda i:s1.getFeature(i) + s2.getFeature(i) , range(d))))
