Ejemplo n.º 1
0
 def testMultSplit3(self):
   """  4 possible results
   """
   d = [(1.,0),
        (1.1,0),
        (1.2,0),
        (1.4,2),
        (1.4,2),
        (1.6,2),
        (2.,2),
        (2.1,1),
        (2.1,1),
        (2.1,1),
        (2.2,1),
        (2.3,1),
        (3.0,3),
        (3.1,3),
        (3.2,3),
        (3.3,3)]
   varValues = map(lambda x:x[0],d)
   resCodes = map(lambda x:x[1],d)
   nPossibleRes =4
   res = Quantize.FindVarMultQuantBounds(varValues,3,resCodes,nPossibleRes)
   target = ([1.30, 2.05, 2.65],1.97722)
   assert Quantize.feq(res[1],target[1],1e-4),\
          'InfoGain comparison failed: %s != %s'%(res[1],target[1])
   assert min(map(lambda x,y:Quantize.feq(x,y,1e-4),res[0],target[0]))==1,\
          'split bound comparison failed: %s != %s'%(res[0],target[0])
Ejemplo n.º 2
0
 def testMultSplit5(self):
   """ dual valued, with an island, a bit noisy
   """
   d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 1), (1.4, 0), (1.6, 1), (2., 1), (2.1, 0), (2.1, 0),
        (2.1, 0), (2.2, 1), (2.3, 0)]
   varValues, resCodes = zip(*d)
   nPossibleRes = 2
   res = Quantize.FindVarMultQuantBounds(varValues, 2, resCodes, nPossibleRes)
   target = ([1.3, 2.05], .34707)
   assert Quantize.feq(res[1],target[1],1e-4),\
          'InfoGain comparison failed: %s != %s'%(res[1],target[1])
   assert min(map(lambda x,y:Quantize.feq(x,y,1e-4),res[0],target[0]))==1,\
          'split bound comparison failed: %s != %s'%(res[0],target[0])
Ejemplo n.º 3
0
 def testMultSplit2(self):
   """ same test as testMultSplit1, but out of order
   """
   d = [(1., 0), (2.1, 1), (1.1, 0), (1.2, 0), (1.4, 2), (1.6, 2), (2., 2), (1.4, 2), (2.1, 1),
        (2.2, 1), (2.1, 1), (2.3, 1)]
   varValues, resCodes = zip(*d)
   nPossibleRes = 3
   res = Quantize.FindVarMultQuantBounds(varValues, 2, resCodes, nPossibleRes)
   target = ([1.3, 2.05], 1.55458)
   assert Quantize.feq(res[1],target[1],1e-4),\
          'InfoGain comparison failed: %s != %s'%(res[1],target[1])
   assert min(map(lambda x,y:Quantize.feq(x,y,1e-4),res[0],target[0]))==1,\
          'split bound comparison failed: %s != %s'%(res[0],target[0])
Ejemplo n.º 4
0
 def testMultSplit3_4results(self):
   # """  4 possible results """
   d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 2), (1.4, 2), (1.6, 2), (2., 2), (2.1, 1), (2.1, 1),
        (2.1, 1), (2.2, 1), (2.3, 1), (3.0, 3), (3.1, 3), (3.2, 3), (3.3, 3)]
   varValues, resCodes = zip(*d)
   nPossibleRes = 4
   res = Quantize.FindVarMultQuantBounds(varValues, 3, resCodes, nPossibleRes)
   target = ([1.30, 2.05, 2.65], 1.97722)
   self.assertTrue(
     Quantize.feq(res[1], target[1], 1e-4),
     'InfoGain comparison failed: %s != %s' % (res[1], target[1]))
   self.assertEqual(
     min(map(lambda x, y: Quantize.feq(x, y, 1e-4), res[0], target[0])), 1,
     'split bound comparison failed: %s != %s' % (res[0], target[0]))
Ejemplo n.º 5
0
 def testMultSplit2_outOfOrder(self):
     # """ same test as testMultSplit1, but out of order """
     d = [(1., 0), (2.1, 1), (1.1, 0), (1.2, 0), (1.4, 2), (1.6, 2), (2., 2), (1.4, 2), (2.1, 1),
          (2.2, 1), (2.1, 1), (2.3, 1)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 3
     res = Quantize.FindVarMultQuantBounds(varValues, 2, resCodes, nPossibleRes)
     target = ([1.3, 2.05], 1.55458)
     self.assertTrue(
       Quantize.feq(res[1], target[1], 1e-4),
       'InfoGain comparison failed: %s != %s' % (res[1], target[1]))
     self.assertEqual(
       min([Quantize.feq(x, y, 1e-4) for x, y in zip(res[0], target[0])]), 1,
       'split bound comparison failed: %s != %s' % (res[0], target[0]))
Ejemplo n.º 6
0
 def testMultSplit4_dualValued_island(self):
   # """ dual valued, with an island """
   d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 1), (1.4, 1), (1.6, 1), (2., 1), (2.1, 0), (2.1, 0),
        (2.1, 0), (2.2, 0), (2.3, 0)]
   varValues, resCodes = zip(*d)
   nPossibleRes = 2
   res = Quantize.FindVarMultQuantBounds(varValues, 2, resCodes, nPossibleRes)
   target = ([1.3, 2.05], .91830)
   self.assertTrue(
     Quantize.feq(res[1], target[1], 1e-4),
     'InfoGain comparison failed: %s != %s' % (res[1], target[1]))
   self.assertEqual(
     min(map(lambda x, y: Quantize.feq(x, y, 1e-4), res[0], target[0])), 1,
     'split bound comparison failed: %s != %s' % (res[0], target[0]))
Ejemplo n.º 7
0
 def testMultSplit1_simple_dual(self):
   # """ simple dual split """
   d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 2), (1.4, 2), (1.6, 2), (2., 2), (2.1, 1), (2.1, 1),
        (2.1, 1), (2.2, 1), (2.3, 1)]
   varValues, resCodes = zip(*d)
   nPossibleRes = 3
   res = Quantize.FindVarMultQuantBounds(varValues, 2, resCodes, nPossibleRes)
   target = ([1.3, 2.05], 1.55458)
   self.assertEqual(
     min(map(lambda x, y: Quantize.feq(x, y, 1e-4), res[0], target[0])), 1,
     'split bound comparison failed: %s != %s' % (res[0], target[0]))
   self.assertTrue(
     Quantize.feq(res[1], target[1], 1e-4),
     'InfoGain comparison failed: %s != %s' % (res[1], target[1]))
Ejemplo n.º 8
0
 def testMultSplit5_dualValued_island_noisy(self):
     # """ dual valued, with an island, a bit noisy """
     d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 1), (1.4, 0), (1.6, 1), (2., 1), (2.1, 0), (2.1, 0),
          (2.1, 0), (2.2, 1), (2.3, 0)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 2
     res = Quantize.FindVarMultQuantBounds(varValues, 2, resCodes, nPossibleRes)
     target = ([1.3, 2.05], .34707)
     self.assertTrue(
       Quantize.feq(res[1], target[1], 1e-4),
       'InfoGain comparison failed: %s != %s' % (res[1], target[1]))
     self.assertEqual(
       min([Quantize.feq(x, y, 1e-4) for x, y in zip(res[0], target[0])]), 1,
       'split bound comparison failed: %s != %s' % (res[0], target[0]))
Ejemplo n.º 9
0
 def testMultSplit5_dualValued_island_noisy(self):
     # """ dual valued, with an island, a bit noisy """
     d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 1), (1.4, 0), (1.6, 1),
          (2., 1), (2.1, 0), (2.1, 0), (2.1, 0), (2.2, 1), (2.3, 0)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 2
     res = Quantize.FindVarMultQuantBounds(varValues, 2, resCodes,
                                           nPossibleRes)
     target = ([1.3, 2.05], .34707)
     self.assertTrue(
         Quantize.feq(res[1], target[1], 1e-4),
         'InfoGain comparison failed: %s != %s' % (res[1], target[1]))
     self.assertEqual(
         min([Quantize.feq(x, y, 1e-4) for x, y in zip(res[0], target[0])]),
         1, 'split bound comparison failed: %s != %s' % (res[0], target[0]))
Ejemplo n.º 10
0
 def testMultSplit4_dualValued_island(self):
     # """ dual valued, with an island """
     d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 1), (1.4, 1), (1.6, 1),
          (2., 1), (2.1, 0), (2.1, 0), (2.1, 0), (2.2, 0), (2.3, 0)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 2
     res = Quantize.FindVarMultQuantBounds(varValues, 2, resCodes,
                                           nPossibleRes)
     target = ([1.3, 2.05], .91830)
     self.assertTrue(
         Quantize.feq(res[1], target[1], 1e-4),
         'InfoGain comparison failed: %s != %s' % (res[1], target[1]))
     self.assertEqual(
         min(map(lambda x, y: Quantize.feq(x, y, 1e-4), res[0], target[0])),
         1, 'split bound comparison failed: %s != %s' % (res[0], target[0]))
Ejemplo n.º 11
0
 def testMultSplit1_simple_dual(self):
     # """ simple dual split """
     d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 2), (1.4, 2), (1.6, 2),
          (2., 2), (2.1, 1), (2.1, 1), (2.1, 1), (2.2, 1), (2.3, 1)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 3
     res = Quantize.FindVarMultQuantBounds(varValues, 2, resCodes,
                                           nPossibleRes)
     target = ([1.3, 2.05], 1.55458)
     self.assertEqual(
         min(map(lambda x, y: Quantize.feq(x, y, 1e-4), res[0], target[0])),
         1, 'split bound comparison failed: %s != %s' % (res[0], target[0]))
     self.assertTrue(
         Quantize.feq(res[1], target[1], 1e-4),
         'InfoGain comparison failed: %s != %s' % (res[1], target[1]))
Ejemplo n.º 12
0
 def testMultSplit2_outOfOrder(self):
     # """ same test as testMultSplit1, but out of order """
     d = [(1., 0), (2.1, 1), (1.1, 0), (1.2, 0), (1.4, 2), (1.6, 2),
          (2., 2), (1.4, 2), (2.1, 1), (2.2, 1), (2.1, 1), (2.3, 1)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 3
     res = Quantize.FindVarMultQuantBounds(varValues, 2, resCodes,
                                           nPossibleRes)
     target = ([1.3, 2.05], 1.55458)
     self.assertTrue(
         Quantize.feq(res[1], target[1], 1e-4),
         'InfoGain comparison failed: %s != %s' % (res[1], target[1]))
     self.assertEqual(
         min([Quantize.feq(x, y, 1e-4) for x, y in zip(res[0], target[0])]),
         1, 'split bound comparison failed: %s != %s' % (res[0], target[0]))
Ejemplo n.º 13
0
 def testMultSplit3_4results(self):
     # """  4 possible results """
     d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 2), (1.4, 2), (1.6, 2),
          (2., 2), (2.1, 1), (2.1, 1), (2.1, 1), (2.2, 1), (2.3, 1),
          (3.0, 3), (3.1, 3), (3.2, 3), (3.3, 3)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 4
     res = Quantize.FindVarMultQuantBounds(varValues, 3, resCodes,
                                           nPossibleRes)
     target = ([1.30, 2.05, 2.65], 1.97722)
     self.assertTrue(
         Quantize.feq(res[1], target[1], 1e-4),
         'InfoGain comparison failed: %s != %s' % (res[1], target[1]))
     self.assertEqual(
         min(map(lambda x, y: Quantize.feq(x, y, 1e-4), res[0], target[0])),
         1, 'split bound comparison failed: %s != %s' % (res[0], target[0]))
Ejemplo n.º 14
0
 def testOneSplit2_noise(self):
     # """ some noise """
     d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 0), (1.4, 1), (1.6, 0),
          (2., 1), (2.1, 1), (2.2, 1), (2.3, 1)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 2
     res = Quantize.FindVarQuantBound(varValues, resCodes, nPossibleRes)
     target = (1.8, 0.60999)
     self.assertEqual(
         list(map(lambda x, y: Quantize.feq(x, y, 1e-4), res, target)),
         [1, 1], 'result comparison failed: %s != %s' % (res, target))
Ejemplo n.º 15
0
 def testOneSplit3(self):
     # """ optimal division not possibe """
     d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 2), (1.4, 2), (1.6, 2),
          (2., 2), (2.1, 1), (2.2, 1), (2.3, 1)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 3
     res = Quantize.FindVarQuantBound(varValues, resCodes, nPossibleRes)
     target = (1.3, 0.88129)
     self.assertEqual(
         [Quantize.feq(x, y, 1e-4) for x, y in zip(res, target)], [1, 1],
         'result comparison failed: %s != %s' % (res, target))
Ejemplo n.º 16
0
 def testOneSplit1(self):
     # """ simple case (clear division) """
     d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 0), (1.4, 0), (1.6, 0),
          (2., 1), (2.1, 1), (2.2, 1), (2.3, 1)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 2
     res = Quantize.FindVarQuantBound(varValues, resCodes, nPossibleRes)
     target = (1.8, 0.97095)
     self.assertEqual(
         [Quantize.feq(x, y, 1e-4) for x, y in zip(res, target)], [1, 1],
         'result comparison failed: %s != %s' % (res, target))
Ejemplo n.º 17
0
 def testOneSplit1(self):
     # """ simple case (clear division) """
     d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 0), (1.4, 0), (1.6, 0), (2., 1), (2.1, 1), (2.2, 1),
          (2.3, 1)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 2
     res = Quantize.FindVarQuantBound(varValues, resCodes, nPossibleRes)
     target = (1.8, 0.97095)
     self.assertEqual(
       [Quantize.feq(x, y, 1e-4) for x, y in zip(res, target)], [1, 1],
       'result comparison failed: %s != %s' % (res, target))
Ejemplo n.º 18
0
 def testOneSplit5_outOfOrder(self):
     # """ same as testOneSplit1 data, but out of order """
     d = [(1., 0), (1.1, 0), (2.2, 1), (1.2, 0), (1.6, 0), (1.4, 0),
          (2., 1), (2.1, 1), (1.4, 0), (2.3, 1)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 2
     res = Quantize.FindVarQuantBound(varValues, resCodes, nPossibleRes)
     target = (1.8, 0.97095)
     self.assertEqual(
         [Quantize.feq(x, y, 1e-4) for x, y in zip(res, target)], [1, 1],
         'result comparison failed: %s != %s' % (res, target))
Ejemplo n.º 19
0
 def testOneSplit4(self):
   """ lots of duplicates
   """
   d = [(1., 0), (1.1, 0), (1.2, 0), (1.2, 1), (1.4, 0), (1.4, 0), (1.6, 0), (2., 1), (2.1, 1),
        (2.1, 1), (2.1, 1), (2.1, 1), (2.2, 1), (2.3, 1)]
   varValues, resCodes = zip(*d)
   nPossibleRes = 2
   res = Quantize.FindVarQuantBound(varValues, resCodes, nPossibleRes)
   target = (1.8, 0.68939)
   assert list(map(lambda x,y:Quantize.feq(x,y,1e-4),res,target))==[1,1],\
          'result comparison failed: %s != %s'%(res,target)
Ejemplo n.º 20
0
 def testOneSplit5(self):
   """ same as testOneSplit1 data, but out of order
   """
   d = [(1., 0), (1.1, 0), (2.2, 1), (1.2, 0), (1.6, 0), (1.4, 0), (2., 1), (2.1, 1), (1.4, 0),
        (2.3, 1)]
   varValues, resCodes = zip(*d)
   nPossibleRes = 2
   res = Quantize.FindVarQuantBound(varValues, resCodes, nPossibleRes)
   target = (1.8, 0.97095)
   assert list(map(lambda x,y:Quantize.feq(x,y,1e-4),res,target))==[1,1],\
          'result comparison failed: %s != %s'%(res,target)
Ejemplo n.º 21
0
 def testOneSplit3(self):
     # """ optimal division not possibe """
     d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 2), (1.4, 2), (1.6, 2), (2., 2), (2.1, 1), (2.2, 1),
          (2.3, 1)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 3
     res = Quantize.FindVarQuantBound(varValues, resCodes, nPossibleRes)
     target = (1.3, 0.88129)
     self.assertEqual(
       [Quantize.feq(x, y, 1e-4) for x, y in zip(res, target)], [1, 1],
       'result comparison failed: %s != %s' % (res, target))
Ejemplo n.º 22
0
 def testOneSplit3(self):
   """ optimal division not possibe
   """
   d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 2), (1.4, 2), (1.6, 2), (2., 2), (2.1, 1), (2.2, 1),
        (2.3, 1)]
   varValues, resCodes = zip(*d)
   nPossibleRes = 3
   res = Quantize.FindVarQuantBound(varValues, resCodes, nPossibleRes)
   target = (1.3, 0.88129)
   assert list(map(lambda x,y:Quantize.feq(x,y,1e-4),res,target))==[1,1],\
          'result comparison failed: %s != %s'%(res,target)
Ejemplo n.º 23
0
 def testOneSplit4_duplicates(self):
     # """ lots of duplicates """
     d = [(1., 0), (1.1, 0), (1.2, 0), (1.2, 1), (1.4, 0), (1.4, 0), (1.6, 0), (2., 1), (2.1, 1),
          (2.1, 1), (2.1, 1), (2.1, 1), (2.2, 1), (2.3, 1)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 2
     res = Quantize.FindVarQuantBound(varValues, resCodes, nPossibleRes)
     target = (1.8, 0.68939)
     self.assertEqual(
       [Quantize.feq(x, y, 1e-4) for x, y in zip(res, target)], [1, 1],
       'result comparison failed: %s != %s' % (res, target))
Ejemplo n.º 24
0
 def testOneSplit2_noise(self):
   # """ some noise """
   d = [(1., 0), (1.1, 0), (1.2, 0), (1.4, 0), (1.4, 1), (1.6, 0), (2., 1), (2.1, 1), (2.2, 1),
        (2.3, 1)]
   varValues, resCodes = zip(*d)
   nPossibleRes = 2
   res = Quantize.FindVarQuantBound(varValues, resCodes, nPossibleRes)
   target = (1.8, 0.60999)
   self.assertEqual(
     list(map(lambda x, y: Quantize.feq(x, y, 1e-4), res, target)), [1, 1],
     'result comparison failed: %s != %s' % (res, target))
Ejemplo n.º 25
0
 def testOneSplit5_outOfOrder(self):
     # """ same as testOneSplit1 data, but out of order """
     d = [(1., 0), (1.1, 0), (2.2, 1), (1.2, 0), (1.6, 0), (1.4, 0), (2., 1), (2.1, 1), (1.4, 0),
          (2.3, 1)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 2
     res = Quantize.FindVarQuantBound(varValues, resCodes, nPossibleRes)
     target = (1.8, 0.97095)
     self.assertEqual(
       [Quantize.feq(x, y, 1e-4) for x, y in zip(res, target)], [1, 1],
       'result comparison failed: %s != %s' % (res, target))
Ejemplo n.º 26
0
 def testOneSplit4_duplicates(self):
     # """ lots of duplicates """
     d = [(1., 0), (1.1, 0), (1.2, 0), (1.2, 1), (1.4, 0), (1.4, 0),
          (1.6, 0), (2., 1), (2.1, 1), (2.1, 1), (2.1, 1), (2.1, 1),
          (2.2, 1), (2.3, 1)]
     varValues, resCodes = zip(*d)
     nPossibleRes = 2
     res = Quantize.FindVarQuantBound(varValues, resCodes, nPossibleRes)
     target = (1.8, 0.68939)
     self.assertEqual(
         [Quantize.feq(x, y, 1e-4) for x, y in zip(res, target)], [1, 1],
         'result comparison failed: %s != %s' % (res, target))
Ejemplo n.º 27
0
 def testOneSplit2(self):
   """ some noise
   """
   d = [(1.,0),
        (1.1,0),
        (1.2,0),
        (1.4,0),
        (1.4,1),
        (1.6,0),
        (2.,1),
        (2.1,1),
        (2.2,1),
        (2.3,1)]
   varValues = map(lambda x:x[0],d)
   resCodes = map(lambda x:x[1],d)
   nPossibleRes = 2
   res = Quantize.FindVarQuantBound(varValues,resCodes,nPossibleRes)
   target = (1.8,0.60999)
   assert map(lambda x,y:Quantize.feq(x,y,1e-4),res,target)==[1,1],\
          'result comparison failed: %s != %s'%(res,target)