def setUp(self): n = 50 m = 4 self.distance = euclidean self.T1 = CoverTree(np.random.randn(n, m), self.distance, leafsize=2) self.T2 = CoverTree(np.random.randn(n, m), self.distance, leafsize=2) self.r = 0.3
class test_small(ConsistencyTests): def setUp(self): self.data = np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]]) self.distance = euclidean self.covertree = CoverTree(self.data, self.distance) self.n = self.covertree.n self.m = np.shape(self.data)[-1] self.x = np.random.randn(3) self.d = 0.5 self.k = 4 def test_nearest(self): assert_array_equal( self.covertree.query((0, 0, 0.1), 1), (0.1, 0)) def test_nearest_two(self): assert_array_equal( self.covertree.query((0, 0, 0.1), 2), ([0.1, 0.9], [0, 1]))
def test_random_ball_vectorized(): n = 20 m = 5 T = CoverTree(np.random.randn(n, m), distance=euclidean) r = T.query_ball_point(np.random.randn(2, 3, m), 1) assert_equal(r.shape, (2, 3)) assert_(isinstance(r[0, 0], list))
def test_random_ball_vectorized(): n = 20 m = 5 T = CoverTree(np.random.randn(n, m), distance=euclidean) r = T.query_ball_point(np.random.randn(2, 3, m), 1) assert_equal(r.shape, (2, 3)) assert_(isinstance(r[0, 0], list))
def testLevelOf(self): ct = CoverTree() input_coords = [[0], [64], [32], [16], [8], [4], [2], [1]] cue = [CPoint(coords) for coords in input_coords] h = CHeap(cue) perm = h.makePerm() test = ct.levelof(perm[1])>ct.levelof(perm[2]) self.assertEqual(test, True)
def testCTInit(self): ct = CoverTree() p = Point([3,4]) ct.insert(p) r = ct.root self.assertEqual(r.point, p) self.assertEqual(r.level, None) self.assertEqual(r.isleaf(),True)
def setUp(self): n = 50 m = 2 self.T1 = CoverTree(np.random.randn(n, m), distance=euclidean, leafsize=2) self.T2 = CoverTree(np.random.randn(n, m), distance=euclidean, leafsize=2)
def setUp(self): self.data = np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]]) self.distance = euclidean self.covertree = CoverTree(self.data, self.distance) self.n = self.covertree.n self.m = np.shape(self.data)[-1] self.x = np.random.randn(3) self.d = 0.5 self.k = 4
def testBuildCT(self): input_coords = [[3,4], [1,1], [2,0] , [2,4], [10,2], [9, 3], [8,5]] cue = [CPoint(coords) for coords in input_coords] h = CHeap(cue) perm = h.makePerm() # for p in perm: # print(p) ct = CoverTree() ct.build(perm) r = ct.root
def setUp(self, distance=euclidean): n = 50 m = 4 self.data1 = np.random.randn(n, m) self.distance = distance self.T1 = CoverTree(self.data1, self.distance, leafsize=2) self.data2 = np.random.randn(n, m) self.T2 = CoverTree(self.data2, self.distance, leafsize=2) self.eps = 0 self.d = 0.2
def test_traverse(): N = 100 np.random.seed(42) data = np.random.random((N, 1)) T = CoverTree(distance) for p in data: T.insert(p) for i, p in T: assert data[i] == p
def test_ball_point_ints(): """Description from test_kdtree.py: Regression test for #1373.""" x, y = np.mgrid[0:4, 0:4] points = zip(x.ravel(), y.ravel()) distance = euclidean tree = CoverTree(points, distance) assert_equal(sorted([4, 8, 9, 12]), sorted(tree.query_ball_point((2, 0), 1))) points = np.asarray(points, dtype=np.float) tree = CoverTree(points, distance) assert_equal(sorted([4, 8, 9, 12]), sorted(tree.query_ball_point((2, 0), 1)))
def testnnsearch(self): coords = [ 200, -190, 57, 40, 20, 10, 170, 100, 195, -50, -30, 340, -120, -230, 310, 300, -300 ] P = [Point([x]) for x in coords] T = CoverTree(P) for query in range(-300, 300, 1): q = Point([query]) nn1 = T.nn(q) nn2 = min(P, key=q.dist) assert nn1.dist(q) == nn2.dist(q)
def test_stable_indexing(): N = 50 np.random.seed(42) D0 = np.random.random((N, 1)) D1 = np.random.random((N, 1)) T = CoverTree(distance, data=D0) T.extend(D1) for i, p in T: if i < N: D = D0 else: D = D1 assert D[i % N] == p
def test_knn(): np.random.seed(42) n = 10 k = 1 data = np.arange(n) T = CoverTree(euclidean, data) for p in data: nns = list(T.knn(p, 1)) assert len(nns) == 1 idx, nn, d = nns[0] print(p, nn, d) assert nn == p assert d == 0
def test_extend(): N = 100 np.random.seed(42) D0 = np.random.random((N, 1)) D1 = np.random.random((N, 1)) T0 = CoverTree(distance, data=D0) T1 = CoverTree(distance, data=D1) T0.extend(T1) for i, p in T0: if i < N: D = D0 else: D = D1 assert p in D
def setUp(self): n = 50 m = 4 self.distance = euclidean self.T1 = CoverTree(np.random.randn(n, m), self.distance, leafsize=2) self.T2 = CoverTree(np.random.randn(n, m), self.distance, leafsize=2) self.r = 0.3
def setUp(self): n = 50 m = 2 self.T1 = CoverTree(np.random.randn(n, m), distance=euclidean, leafsize=2) self.T2 = CoverTree(np.random.randn(n, m), distance=euclidean, leafsize=2)
def test_onetree_query(): np.random.seed(0) n = 100 k = 4 points = np.random.randn(n, k) distance = euclidean T = CoverTree(points, distance) yield check_onetree_query, T, 0.1 points = np.random.randn(3 * n, k) points[:n] *= 0.001 points[n:2 * n] += 2 T = CoverTree(points, distance) yield check_onetree_query, T, 0.1 yield check_onetree_query, T, 0.001 yield check_onetree_query, T, 0.00001 yield check_onetree_query, T, 1e-6
def testconstruction(self): """ a = 0 / \ c = -19 b = 20 / d = 15 """ a, b, c, d = [Point([x]) for x in [0, 20, -19, 15]] T = CoverTree([a, b, c, d]) self.assertEqual(T.root, a) self.assertTrue(b in T.children(a, 5)) self.assertTrue(c in T.children(a, 5)) self.assertTrue(d not in T.children(a, 5)) self.assertTrue(c not in T.children(a, 4)) self.assertEqual(set(T.ch), {(a, 5), (b, 3)})
class test_small(ConsistencyTests): def setUp(self): self.data = np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]]) self.distance = euclidean self.covertree = CoverTree(self.data, self.distance) self.n = self.covertree.n self.m = np.shape(self.data)[-1] self.x = np.random.randn(3) self.d = 0.5 self.k = 4 def test_nearest(self): assert_array_equal(self.covertree.query((0, 0, 0.1), 1), (0.1, 0)) def test_nearest_two(self): assert_array_equal(self.covertree.query((0, 0, 0.1), 2), ([0.1, 0.9], [0, 1]))
def setUp(self): self.n = 100 self.m = 4 self.data = np.random.randn(self.n, self.m) self.distance = euclidean self.covertree = CoverTree(self.data, self.distance, leafsize=2) self.x = np.random.randn(self.m) self.d = 0.2 self.k = 10
def setUp(self, distance=euclidean): n = 100 m = 4 self.data = np.random.randn(n, m) self.distance = distance self.T = CoverTree(self.data, self.distance, leafsize=2) self.x = np.random.randn(m) self.eps = 0 self.d = 0.2
def constructTree(): global ct,ctTime,data # d=[] # for i in xrange(500): # d.append([random.randint(0, 13),random.randint(0, 13)]) ctStartTime=datetime.datetime.now() ct = CoverTree(data, euclidean, leafsize=20) ctEndTime=datetime.datetime.now() ctTime=ctTime+(ctEndTime-ctStartTime).microseconds
def setUp(self): self.data = np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]]) self.distance = euclidean self.covertree = CoverTree(self.data, self.distance)
def testCTwith2points(self): # Make some points p = Point([3,4]) q = Point([1,1]) q.updatepred(p) # Make a covertree ct = CoverTree() ct.insert(p) ct.insert(q) r = ct.root # The root should be p self.assertEqual(r.point, p) # The root should have 2 children self.assertEqual(len(r.ch), 2) # The children should have points 1 and 2 self.assertEqual({r.ch[0].point, r.ch[1].point}, {p,q}) # Updated leaves points to new p self.assertEqual(ct.leaves[p].level, ct.leaves[q].level)
class test_sparse_distance_matrix: def setUp(self): n = 50 m = 4 self.distance = euclidean self.T1 = CoverTree(np.random.randn(n, m), self.distance, leafsize=2) self.T2 = CoverTree(np.random.randn(n, m), self.distance, leafsize=2) self.r = 0.3 def test_consistency_with_neighbors(self): M = self.T1.sparse_distance_matrix(self.T2, self.r) r = self.T1.query_ball_tree(self.T2, self.r) for i, l in enumerate(r): for j in l: assert_equal(M[i, j], self.distance(self.T1.data[i], self.T2.data[j])) for ((i, j), d) in M.items(): assert_(j in r[i]) def test_zero_distance(self): M = self.T1.sparse_distance_matrix(self.T1, self.r)
class test_count_neighbors: def setUp(self): n = 50 m = 2 self.T1 = CoverTree(np.random.randn(n, m), distance=euclidean, leafsize=2) self.T2 = CoverTree(np.random.randn(n, m), distance=euclidean, leafsize=2) def test_one_radius(self): r = 0.2 assert_equal( self.T1.count_neighbors(self.T2, r), np.sum([len(l) for l in self.T1.query_ball_tree(self.T2, r)])) def test_large_radius(self): r = 1000 assert_equal( self.T1.count_neighbors(self.T2, r), np.sum([len(l) for l in self.T1.query_ball_tree(self.T2, r)])) def test_multiple_radius(self): rs = np.exp(np.linspace(np.log(0.01), np.log(10), 3)) results = self.T1.count_neighbors(self.T2, rs) assert_(np.all(np.diff(results) >= 0)) for r, result in zip(rs, results): assert_equal(self.T1.count_neighbors(self.T2, r), result)
class test_count_neighbors: def setUp(self): n = 50 m = 2 self.T1 = CoverTree(np.random.randn(n, m), distance=euclidean, leafsize=2) self.T2 = CoverTree(np.random.randn(n, m), distance=euclidean, leafsize=2) def test_one_radius(self): r = 0.2 assert_equal( self.T1.count_neighbors(self.T2, r), np.sum([len(l) for l in self.T1.query_ball_tree(self.T2, r)])) def test_large_radius(self): r = 1000 assert_equal( self.T1.count_neighbors(self.T2, r), np.sum([len(l) for l in self.T1.query_ball_tree(self.T2, r)])) def test_multiple_radius(self): rs = np.exp(np.linspace(np.log(0.01), np.log(10), 3)) results = self.T1.count_neighbors(self.T2, rs) assert_(np.all(np.diff(results) >= 0)) for r, result in zip(rs, results): assert_equal(self.T1.count_neighbors(self.T2, r), result)
class test_sparse_distance_matrix: def setUp(self): n = 50 m = 4 self.distance = euclidean self.T1 = CoverTree(np.random.randn(n, m), self.distance, leafsize=2) self.T2 = CoverTree(np.random.randn(n, m), self.distance, leafsize=2) self.r = 0.3 def test_consistency_with_neighbors(self): M = self.T1.sparse_distance_matrix(self.T2, self.r) r = self.T1.query_ball_tree(self.T2, self.r) for i, l in enumerate(r): for j in l: assert_equal( M[i, j], self.distance(self.T1.data[i], self.T2.data[j])) for ((i, j), d) in M.items(): assert_(j in r[i]) def test_zero_distance(self): M = self.T1.sparse_distance_matrix(self.T1, self.r)
def testCTwith3points(self): #get permutation input_coords = [[0], [64], [32], [16], [8], [4], [2], [1]] cue = [CPoint(coords) for coords in input_coords] h = CHeap(cue) perm = h.makePerm() ct = CoverTree() ct.insert(perm[0]) ct.insert(perm[1]) ct.insert(perm[4]) r = ct.root self.assertEqual(r.point, perm[0]) self.assertEqual(r.level, 7) self.assertEqual({r.ch[0].point, r.ch[1].point}, {perm[0],perm[1]}) lowRoot = ct.leaves[perm[0]] self.assertEqual(lowRoot.level, 3) lowRootPar = lowRoot.par self.assertEqual(lowRootPar.point, perm[0]) self.assertEqual(lowRootPar.level, 4)
def test_neighbors(): N = 1000 np.random.seed(42) data = np.random.random((N, 1)) # data = np.array([0, 1, 2, 3, 4, 4.5, 5, 5.5, 6, 7, 8, 9]) # N = len(data) # data = data.reshape((N, 1)) T = CoverTree(distance) for p in data: T.insert(p) subset = data[np.random.choice(np.arange(len(data)), size=1)] # subset = np.array([5]).reshape((1,1)) realdist = cdist(subset, data) # import pdb;pdb.set_trace() for i, p in enumerate(subset): r = 0.01 result = T.neighbors(p, r) ix, ns, ds = zip(*result) ns = np.array(ns) ds = np.array(ds) real = realdist[i][realdist[i] <= r] assert (data[np.array(ix)] == ns).all() assert ds.max() <= r assert len(ds) == len(real) assert sorted(ds) == sorted(real) # print 'N({}, {}) =\n{}'.format(p, r, ns.reshape((len(ns),))) # print 'D =' # print np.array(sorted(ds)) print('Test Neighborhood query: OK')
class test_vectorization: def setUp(self): self.data = np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]]) self.distance = euclidean self.covertree = CoverTree(self.data, self.distance) def test_single_query(self): d, i = self.covertree.query(np.array([0, 0, 0])) assert_(isinstance(d, float)) assert_(np.issubdtype(i, int)) def test_vectorized_query(self): d, i = self.covertree.query(np.zeros((2, 4, 3))) assert_equal(np.shape(d), (2, 4)) assert_equal(np.shape(i), (2, 4)) def test_single_query_multiple_neighbors(self): s = 23 kk = self.covertree.n + s d, i = self.covertree.query(np.array([0, 0, 0]), k=kk) assert_equal(np.shape(d), (kk,)) assert_equal(np.shape(i), (kk,)) assert_(np.all(~np.isfinite(d[-s:]))) assert_(np.all(i[-s:] == self.covertree.n)) def test_vectorized_query_multiple_neighbors(self): s = 23 kk = self.covertree.n + s d, i = self.covertree.query(np.zeros((2, 4, 3)), k=kk) assert_equal(np.shape(d), (2, 4, kk)) assert_equal(np.shape(i), (2, 4, kk)) assert_(np.all(~np.isfinite(d[:, :, -s:]))) assert_(np.all(i[:, :, -s:] == self.covertree.n)) def test_single_query_all_neighbors(self): d, i = self.covertree.query([0, 0, 0], k=None, distance_upper_bound=1.1) assert_(isinstance(d, list)) assert_(isinstance(i, list)) def test_vectorized_query_all_neighbors(self): d, i = self.covertree.query(np.zeros((2, 4, 3)), k=None, distance_upper_bound=1.1) assert_equal(np.shape(d), (2, 4)) assert_equal(np.shape(i), (2, 4)) assert_(isinstance(d[0, 0], list)) assert_(isinstance(i[0, 0], list))
def setUp(self): self.data = np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]]) self.distance = euclidean self.covertree = CoverTree(self.data, self.distance) self.n = self.covertree.n self.m = np.shape(self.data)[-1] self.x = np.random.randn(3) self.d = 0.5 self.k = 4
def test_ball_point_ints(): """Description from test_kdtree.py: Regression test for #1373.""" x, y = np.mgrid[0:4, 0:4] points = zip(x.ravel(), y.ravel()) distance = euclidean tree = CoverTree(points, distance) assert_equal(sorted([4, 8, 9, 12]), sorted(tree.query_ball_point((2, 0), 1))) points = np.asarray(points, dtype=np.float) tree = CoverTree(points, distance) assert_equal(sorted([4, 8, 9, 12]), sorted(tree.query_ball_point((2, 0), 1)))
class test_vectorization: def setUp(self): self.data = np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]]) self.distance = euclidean self.covertree = CoverTree(self.data, self.distance) def test_single_query(self): d, i = self.covertree.query(np.array([0, 0, 0])) assert_(isinstance(d, float)) assert_(np.issubdtype(i, int)) def test_vectorized_query(self): d, i = self.covertree.query(np.zeros((2, 4, 3))) assert_equal(np.shape(d), (2, 4)) assert_equal(np.shape(i), (2, 4)) def test_single_query_multiple_neighbors(self): s = 23 kk = self.covertree.n + s d, i = self.covertree.query(np.array([0, 0, 0]), k=kk) assert_equal(np.shape(d), (kk, )) assert_equal(np.shape(i), (kk, )) assert_(np.all(~np.isfinite(d[-s:]))) assert_(np.all(i[-s:] == self.covertree.n)) def test_vectorized_query_multiple_neighbors(self): s = 23 kk = self.covertree.n + s d, i = self.covertree.query(np.zeros((2, 4, 3)), k=kk) assert_equal(np.shape(d), (2, 4, kk)) assert_equal(np.shape(i), (2, 4, kk)) assert_(np.all(~np.isfinite(d[:, :, -s:]))) assert_(np.all(i[:, :, -s:] == self.covertree.n)) def test_single_query_all_neighbors(self): d, i = self.covertree.query([0, 0, 0], k=None, distance_upper_bound=1.1) assert_(isinstance(d, list)) assert_(isinstance(i, list)) def test_vectorized_query_all_neighbors(self): d, i = self.covertree.query(np.zeros((2, 4, 3)), k=None, distance_upper_bound=1.1) assert_equal(np.shape(d), (2, 4)) assert_equal(np.shape(i), (2, 4)) assert_(isinstance(d[0, 0], list)) assert_(isinstance(i[0, 0], list))
def test_contains(): N = 100 np.random.seed(42) data = np.random.random((N, 1)) T = CoverTree(distance) for p in data: T.insert(p) points = 10 + np.random.random((int(N * 0.1), 1)) for p in points: assert not T.contains(p) for p in np.random.random((int(N * 0.1), 1)): assert not T.contains(p)
np.random.seed(seed=3) print('Building cover tree') x = np.random.rand(500000, 128) with open('train_data.bin', 'wb') as f: np.array(x.shape, dtype='int32').tofile(f) x.tofile(f) print(x[0, 0], x[0, 1], x[1, 0]) mx = np.mean(x, 0) dists = np.array([np.sqrt(np.dot(xv - mx, xv - mx)) for xv in x]) idx = np.argsort(-dists) xs = x[idx] #print sc.spatial.distance.squareform(sc.spatial.distance.pdist(x, 'euclidean')) t = gt() ct = CoverTree.from_matrix(x) b_t = gt() - t #ct.display() print("Building time:", b_t, "seconds") print("Test covering: ", ct.test_covering()) print('Generate random points') y = np.random.rand(5000, 128) with open('test_data.bin', 'wb') as f: np.array(y.shape, dtype='int32').tofile(f) y.tofile(f) print('Test Nearest Neighbour: ') t = gt() a = ct.NearestNeighbour(y)
np.random.seed(seed=3) print 'Building cover tree' x = np.random.rand(500000,128) with open('train_data.bin', 'wb') as f: np.array(x.shape, dtype='int32').tofile(f) x.tofile(f) print x[0,0], x[0,1], x[1,0] mx = np.mean(x,0) dists = np.array([np.sqrt(np.dot(xv-mx,xv-mx)) for xv in x]) idx = np.argsort(-dists) xs = x[idx] #print sc.spatial.distance.squareform(sc.spatial.distance.pdist(x, 'euclidean')) t = gt() ct = CoverTree.from_matrix(x) b_t = gt() - t #ct.display() print "Building time:", b_t, "seconds" print "Test covering: ", ct.test_covering() print 'Generate random points' y = np.random.rand(5000,128) with open('test_data.bin', 'wb') as f: np.array(y.shape, dtype='int32').tofile(f) y.tofile(f) print 'Test Nearest Neighbour: ' t = gt() a = ct.NearestNeighbour(y)
def test_query_pairs_single_node(): distance = euclidean tree = CoverTree([[0, 1]], distance) assert_equal(tree.query_pairs(0.5), set())
def test_query_pairs_single_node(): distance = euclidean tree = CoverTree([[0, 1]], distance) assert_equal(tree.query_pairs(0.5), set())
def test_covertree(): seed(1) total_tests = 0 passed_tests = 0 n_points = 400 k = 5 pts = [(random(), random()) for _ in xrange(n_points)] gt = time.time print "Build cover tree of", n_points, "2D-points" t = gt() ct = CoverTree(distance) for p in pts: ct.insert(p) b_t = gt() - t print "Building time:", b_t, "seconds" print "==== Check that all cover tree invariants are satisfied ====" if ct.check_invariants(): print "OK!" passed_tests += 1 else: print "NOT OK!" total_tests += 1 print "==== Write test1.dot, dotty file of the built tree ====" with open("test1.dot", "w") as testDottyFile1: ct.writeDotty(testDottyFile1) print "==== Test saving/loading (via pickle)" ctFileName = "test.ct" print "Save cover tree under", ctFileName t = gt() ct_file = open("test.ct", "w") pickle.dump(ct, ct_file) ct_file.close() print "Saving time:", gt() - t del ct_file del ct # load ct print "Reload", ctFileName t = gt() ct_file = open("test.ct") ct = pickle.load(ct_file) ct_file.close() print "Loading time:", gt() - t print "==== Test " + str(k) + "-nearest neighbors cover tree query ====" query = (0.5, 0.5) # naive nearest neighbor t = gt() naive_results = knn(k, query, pts, distance) # print "resultNN =", resultNN n_t = gt() - t print "Time to run a naive " + str(k) + "-nn query:", n_t, "seconds" #cover-tree nearest neighbor t = gt() results = ct.knn(k, query, True) # print "result =", result ct_t = gt() - t print "Time to run a cover tree " + str(k) + "-nn query:", ct_t, "seconds" if all([distance(r, nr) != 0 for r, nr in zip(results, naive_results)]): print "NOT OK!" print results print "!=" print naive_results else: print "OK!" print results print "==" print naive_results print "Cover tree query is", n_t / ct_t, "faster" passed_tests += 1 total_tests += 1 # you need pylab for that # plot(pts[0], pts[1], 'rx') # plot([query[0]], [query[1]], 'go') # plot([naive_results[0][0]], [naive_results[0][1]], 'y^') # plot([results[0][0]], [results[0][1]], 'mo') # test knn_insert print "==== Test knn_insert method ====" t = gt() results2 = ct.knn_insert(k, query, True) ct_t = gt() - t print "Time to run a cover tree " + str(k) + "-nn query:", ct_t, "seconds" if all([distance(r, nr) != 0 for r, nr in zip(results2, naive_results)]): print "NOT OK!" print results2 print "!=" print naive_results else: print "OK!" print results2 print "==" print naive_results print "Cover tree query is", n_t / ct_t, "faster" passed_tests += 1 total_tests += 1 print "==== Check that all cover tree invariants are satisfied ====" if ct.check_invariants(): print "OK!" passed_tests += 1 else: print "NOT OK!" total_tests += 1 print "==== Write test2.dot, dotty file of the built tree after knn_insert ====" with open("test2.dot", "w") as testDottyFile2: ct.writeDotty(testDottyFile2) # test find print "==== Test cover tree find method ====" if ct.find(query): print "OK!" passed_tests += 1 else: print "NOT OK!" total_tests += 1 # printDotty prints the tree that was generated in dotty format, # for more info on the format, see http://graphviz.org/ # ct.printDotty() # show() print passed_tests, "tests out of", total_tests, "have passed"
def test_neighbors_of_empty_tree(): T = CoverTree(distance) nn = T.neighbors(1, 1) assert len(nn) == 0
def testinsertduplicate(self): coords = [0, 200, 300, 200] P = [Point([x]) for x in coords] T = CoverTree(P)
def setUp(self): test_small.setUp(self) self.covertree = CoverTree(self.data, self.distance, leafsize=1)
def test_covertree(): total_tests = 0 passed_tests = 0 n_points = 400 k = 5 pts = rd.random((n_points, 2)) gt = time.time print("Build cover tree of", n_points, "2D-points") t = gt() ct = CoverTree(distance) for p in pts: ct.insert(p) b_t = gt() - t print("Building time:", b_t, "seconds") print("==== Check that all cover tree invariants are satisfied ====") assert ct._check_invariants() print("==== Write test1.dot, dotty file of the built tree ====") with open("test1.dot", "w") as testDottyFile1: ct.writeDotty(testDottyFile1) ''' print "==== Test saving/loading (via pickle)" ctFileName = "test.ct" print "Save cover tree under", ctFileName t = gt() ct_file = open("test.ct", "w") pickle.dump(ct, ct_file) ct_file.close() print "Saving time:", gt() - t del ct_file del ct # load ct print "Reload", ctFileName t = gt() ct_file = open("test.ct") ct = pickle.load(ct_file) ct_file.close() print "Loading time:", gt() - t ''' print("==== Test " + str(k) + "-nearest neighbors cover tree query ====") query = (0.5, 0.5) # naive nearest neighbor t = gt() naive_results = knn(k, query, pts, distance) # print "resultNN =", resultNN n_t = gt() - t print("Time to run a naive " + str(k) + "-nn query:", n_t, "seconds") # cover-tree nearest neighbor t = gt() results = ct.knn(query, k) # print "result =", result ct_t = gt() - t print("Time to run a cover tree " + str(k) + "-nn query:", ct_t, "seconds") results = list(map(operator.itemgetter(1), results)) assert all([distance(r, nr) == 0 for r, nr in zip(results, naive_results)]) print("Cover tree query is", n_t / ct_t, "faster") # you need pylab for that # plot(pts[0], pts[1], 'rx') # plot([query[0]], [query[1]], 'go') # plot([naive_results[0][0]], [naive_results[0][1]], 'y^') # plot([results[0][0]], [results[0][1]], 'mo') print( "==== Write test2.dot, dotty file of the built tree after knn_insert ====" ) with open("test2.dot", "w") as testDottyFile2: ct.writeDotty(testDottyFile2) # printDotty prints the tree that was generated in dotty format, # for more info on the format, see http://graphviz.org/ # ct.printDotty() # show() print(passed_tests, "tests out of", total_tests, "have passed")
def test_covertree(): seed(1) total_tests = 0 passed_tests = 0 n_points = 400 k = 5 pts = [(random(), random()) for _ in xrange(n_points)] gt = time.time print "Build cover tree of", n_points, "2D-points" t = gt() ct = CoverTree(distance) for p in pts: ct.insert(p) b_t = gt() - t print "Building time:", b_t, "seconds" print "==== Check that all cover tree invariants are satisfied ====" if ct.check_invariants(): print "OK!" passed_tests += 1 else: print "NOT OK!" total_tests += 1 print "==== Write test1.dot, dotty file of the built tree ====" with open("test1.dot", "w") as testDottyFile1: ct.writeDotty(testDottyFile1) print "==== Test saving/loading (via pickle)" ctFileName = "test.ct" print "Save cover tree under", ctFileName t = gt() ct_file = open("test.ct", "w") pickle.dump(ct, ct_file) ct_file.close() print "Saving time:", gt() - t del ct_file del ct # load ct print "Reload", ctFileName t = gt() ct_file = open("test.ct") ct = pickle.load(ct_file) ct_file.close() print "Loading time:", gt() - t print "==== Test " + str(k) + "-nearest neighbors cover tree query ====" query = (0.5,0.5) # naive nearest neighbor t = gt() naive_results = knn(k, query, pts, distance) # print "resultNN =", resultNN n_t = gt() - t print "Time to run a naive " + str(k) + "-nn query:", n_t, "seconds" #cover-tree nearest neighbor t = gt() results = ct.knn(k, query, True) # print "result =", result ct_t = gt() - t print "Time to run a cover tree " + str(k) + "-nn query:", ct_t, "seconds" if all([distance(r, nr) != 0 for r, nr in zip(results, naive_results)]): print "NOT OK!" print results print "!=" print naive_results else: print "OK!" print results print "==" print naive_results print "Cover tree query is", n_t/ct_t, "faster" passed_tests += 1 total_tests += 1 # you need pylab for that # plot(pts[0], pts[1], 'rx') # plot([query[0]], [query[1]], 'go') # plot([naive_results[0][0]], [naive_results[0][1]], 'y^') # plot([results[0][0]], [results[0][1]], 'mo') # test knn_insert print "==== Test knn_insert method ====" t = gt() results2 = ct.knn_insert(k, query, True) ct_t = gt() - t print "Time to run a cover tree " + str(k) + "-nn query:", ct_t, "seconds" if all([distance(r, nr) != 0 for r, nr in zip(results2, naive_results)]): print "NOT OK!" print results2 print "!=" print naive_results else: print "OK!" print results2 print "==" print naive_results print "Cover tree query is", n_t/ct_t, "faster" passed_tests += 1 total_tests += 1 print "==== Check that all cover tree invariants are satisfied ====" if ct.check_invariants(): print "OK!" passed_tests += 1 else: print "NOT OK!" total_tests += 1 print "==== Write test2.dot, dotty file of the built tree after knn_insert ====" with open("test2.dot", "w") as testDottyFile2: ct.writeDotty(testDottyFile2) # test find print "==== Test cover tree find method ====" if ct.find(query): print "OK!" passed_tests += 1 else: print "NOT OK!" total_tests += 1 # printDotty prints the tree that was generated in dotty format, # for more info on the format, see http://graphviz.org/ # ct.printDotty() # show() print passed_tests, "tests out of", total_tests, "have passed"
def setUp(self): self.data = np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]]) self.distance = euclidean self.covertree = CoverTree(self.data, self.distance)