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)
