mirror of
https://github.com/vale981/ray
synced 2025-03-06 10:31:39 -05:00
clean up tests (#340)
This commit is contained in:
Philipp Moritz
Robert Nishihara
parent
eae27f23ac
commit
0ac4e29b1f
2 changed files with 57 additions and 69 deletions
|
|
@ -4,6 +4,7 @@ import numpy as np
|
|||
import time
|
||||
import subprocess32 as subprocess
|
||||
import os
|
||||
from numpy.testing import assert_equal, assert_almost_equal
|
||||
|
||||
import ray.array.remote as ra
|
||||
import ray.array.distributed as da
|
||||
|
|
@ -18,19 +19,19 @@ class RemoteArrayTest(unittest.TestCase):
|
|||
# test eye
|
||||
object_id = ra.eye.remote(3)
|
||||
val = ray.get(object_id)
|
||||
self.assertTrue(np.alltrue(val == np.eye(3)))
|
||||
assert_almost_equal(val, np.eye(3))
|
||||
|
||||
# test zeros
|
||||
object_id = ra.zeros.remote([3, 4, 5])
|
||||
val = ray.get(object_id)
|
||||
self.assertTrue(np.alltrue(val == np.zeros([3, 4, 5])))
|
||||
assert_equal(val, np.zeros([3, 4, 5]))
|
||||
|
||||
# test qr - pass by value
|
||||
a_val = np.random.normal(size=[10, 11])
|
||||
q_id, r_id = ra.linalg.qr.remote(a_val)
|
||||
q_val = ray.get(q_id)
|
||||
r_val = ray.get(r_id)
|
||||
self.assertTrue(np.allclose(np.dot(q_val, r_val), a_val))
|
||||
assert_almost_equal(np.dot(q_val, r_val), a_val)
|
||||
|
||||
# test qr - pass by objectid
|
||||
a = ra.random.normal.remote([10, 13])
|
||||
|
|
@ -38,7 +39,7 @@ class RemoteArrayTest(unittest.TestCase):
|
|||
a_val = ray.get(a)
|
||||
q_val = ray.get(q_id)
|
||||
r_val = ray.get(r_id)
|
||||
self.assertTrue(np.allclose(np.dot(q_val, r_val), a_val))
|
||||
assert_almost_equal(np.dot(q_val, r_val), a_val)
|
||||
|
||||
ray.worker.cleanup()
|
||||
|
||||
|
|
@ -65,7 +66,7 @@ class DistributedArrayTest(unittest.TestCase):
|
|||
a = ra.ones.remote([da.BLOCK_SIZE, da.BLOCK_SIZE])
|
||||
b = ra.zeros.remote([da.BLOCK_SIZE, da.BLOCK_SIZE])
|
||||
x = da.DistArray([2 * da.BLOCK_SIZE, da.BLOCK_SIZE], np.array([[a], [b]]))
|
||||
self.assertTrue(np.alltrue(x.assemble() == np.vstack([np.ones([da.BLOCK_SIZE, da.BLOCK_SIZE]), np.zeros([da.BLOCK_SIZE, da.BLOCK_SIZE])])))
|
||||
assert_equal(x.assemble(), np.vstack([np.ones([da.BLOCK_SIZE, da.BLOCK_SIZE]), np.zeros([da.BLOCK_SIZE, da.BLOCK_SIZE])]))
|
||||
|
||||
ray.worker.cleanup()
|
||||
|
||||
|
|
@ -75,25 +76,25 @@ class DistributedArrayTest(unittest.TestCase):
|
|||
ray.init(start_ray_local=True, num_objstores=2, num_workers=10)
|
||||
|
||||
x = da.zeros.remote([9, 25, 51], "float")
|
||||
self.assertTrue(np.alltrue(ray.get(da.assemble.remote(x)) == np.zeros([9, 25, 51])))
|
||||
assert_equal(ray.get(da.assemble.remote(x)), np.zeros([9, 25, 51]))
|
||||
|
||||
x = da.ones.remote([11, 25, 49], dtype_name="float")
|
||||
self.assertTrue(np.alltrue(ray.get(da.assemble.remote(x)) == np.ones([11, 25, 49])))
|
||||
assert_equal(ray.get(da.assemble.remote(x)), np.ones([11, 25, 49]))
|
||||
|
||||
x = da.random.normal.remote([11, 25, 49])
|
||||
y = da.copy.remote(x)
|
||||
self.assertTrue(np.alltrue(ray.get(da.assemble.remote(x)) == ray.get(da.assemble.remote(y))))
|
||||
assert_equal(ray.get(da.assemble.remote(x)), ray.get(da.assemble.remote(y)))
|
||||
|
||||
x = da.eye.remote(25, dtype_name="float")
|
||||
self.assertTrue(np.alltrue(ray.get(da.assemble.remote(x)) == np.eye(25)))
|
||||
assert_equal(ray.get(da.assemble.remote(x)), np.eye(25))
|
||||
|
||||
x = da.random.normal.remote([25, 49])
|
||||
y = da.triu.remote(x)
|
||||
self.assertTrue(np.alltrue(ray.get(da.assemble.remote(y)) == np.triu(ray.get(da.assemble.remote(x)))))
|
||||
assert_equal(ray.get(da.assemble.remote(y)), np.triu(ray.get(da.assemble.remote(x))))
|
||||
|
||||
x = da.random.normal.remote([25, 49])
|
||||
y = da.tril.remote(x)
|
||||
self.assertTrue(np.alltrue(ray.get(da.assemble.remote(y)) == np.tril(ray.get(da.assemble.remote(x)))))
|
||||
assert_equal(ray.get(da.assemble.remote(y)), np.tril(ray.get(da.assemble.remote(x))))
|
||||
|
||||
x = da.random.normal.remote([25, 49])
|
||||
y = da.random.normal.remote([49, 18])
|
||||
|
|
@ -101,33 +102,33 @@ class DistributedArrayTest(unittest.TestCase):
|
|||
w = da.assemble.remote(z)
|
||||
u = da.assemble.remote(x)
|
||||
v = da.assemble.remote(y)
|
||||
np.allclose(ray.get(w), np.dot(ray.get(u), ray.get(v)))
|
||||
self.assertTrue(np.allclose(ray.get(w), np.dot(ray.get(u), ray.get(v))))
|
||||
assert_almost_equal(ray.get(w), np.dot(ray.get(u), ray.get(v)))
|
||||
assert_almost_equal(ray.get(w), np.dot(ray.get(u), ray.get(v)))
|
||||
|
||||
# test add
|
||||
x = da.random.normal.remote([23, 42])
|
||||
y = da.random.normal.remote([23, 42])
|
||||
z = da.add.remote(x, y)
|
||||
self.assertTrue(np.allclose(ray.get(da.assemble.remote(z)), ray.get(da.assemble.remote(x)) + ray.get(da.assemble.remote(y))))
|
||||
assert_almost_equal(ray.get(da.assemble.remote(z)), ray.get(da.assemble.remote(x)) + ray.get(da.assemble.remote(y)))
|
||||
|
||||
# test subtract
|
||||
x = da.random.normal.remote([33, 40])
|
||||
y = da.random.normal.remote([33, 40])
|
||||
z = da.subtract.remote(x, y)
|
||||
self.assertTrue(np.allclose(ray.get(da.assemble.remote(z)), ray.get(da.assemble.remote(x)) - ray.get(da.assemble.remote(y))))
|
||||
assert_almost_equal(ray.get(da.assemble.remote(z)), ray.get(da.assemble.remote(x)) - ray.get(da.assemble.remote(y)))
|
||||
|
||||
# test transpose
|
||||
x = da.random.normal.remote([234, 432])
|
||||
y = da.transpose.remote(x)
|
||||
self.assertTrue(np.alltrue(ray.get(da.assemble.remote(x)).T == ray.get(da.assemble.remote(y))))
|
||||
assert_equal(ray.get(da.assemble.remote(x)).T, ray.get(da.assemble.remote(y)))
|
||||
|
||||
# test numpy_to_dist
|
||||
x = da.random.normal.remote([23, 45])
|
||||
y = da.assemble.remote(x)
|
||||
z = da.numpy_to_dist.remote(y)
|
||||
w = da.assemble.remote(z)
|
||||
self.assertTrue(np.alltrue(ray.get(da.assemble.remote(x)) == ray.get(da.assemble.remote(z))))
|
||||
self.assertTrue(np.alltrue(ray.get(y) == ray.get(w)))
|
||||
assert_equal(ray.get(da.assemble.remote(x)), ray.get(da.assemble.remote(z)))
|
||||
assert_equal(ray.get(y), ray.get(w))
|
||||
|
||||
# test da.tsqr
|
||||
for shape in [[123, da.BLOCK_SIZE], [7, da.BLOCK_SIZE], [da.BLOCK_SIZE, da.BLOCK_SIZE], [da.BLOCK_SIZE, 7], [10 * da.BLOCK_SIZE, da.BLOCK_SIZE]]:
|
||||
|
|
@ -138,9 +139,9 @@ class DistributedArrayTest(unittest.TestCase):
|
|||
q_val = ray.get(da.assemble.remote(q))
|
||||
r_val = ray.get(r)
|
||||
self.assertTrue(r_val.shape == (K, shape[1]))
|
||||
self.assertTrue(np.alltrue(r_val == np.triu(r_val)))
|
||||
self.assertTrue(np.allclose(x_val, np.dot(q_val, r_val)))
|
||||
self.assertTrue(np.allclose(np.dot(q_val.T, q_val), np.eye(K)))
|
||||
assert_equal(r_val, np.triu(r_val))
|
||||
assert_almost_equal(x_val, np.dot(q_val, r_val))
|
||||
assert_almost_equal(np.dot(q_val.T, q_val), np.eye(K))
|
||||
|
||||
# test da.linalg.modified_lu
|
||||
def test_modified_lu(d1, d2):
|
||||
|
|
@ -158,9 +159,9 @@ class DistributedArrayTest(unittest.TestCase):
|
|||
s_mat = np.zeros((d1, d2))
|
||||
for i in range(len(s_val)):
|
||||
s_mat[i, i] = s_val[i]
|
||||
self.assertTrue(np.allclose(q_val - s_mat, np.dot(l_val, u_val))) # check that q - s = l * u
|
||||
self.assertTrue(np.alltrue(np.triu(u_val) == u_val)) # check that u is upper triangular
|
||||
self.assertTrue(np.alltrue(np.tril(l_val) == l_val)) # check that l is lower triangular
|
||||
assert_almost_equal(q_val - s_mat, np.dot(l_val, u_val)) # check that q - s = l * u
|
||||
assert_equal(np.triu(u_val), u_val) # check that u is upper triangular
|
||||
assert_equal(np.tril(l_val), l_val) # check that l is lower triangular
|
||||
|
||||
for d1, d2 in [(100, 100), (99, 98), (7, 5), (7, 7), (20, 7), (20, 10)]:
|
||||
test_modified_lu(d1, d2)
|
||||
|
|
@ -178,8 +179,8 @@ class DistributedArrayTest(unittest.TestCase):
|
|||
tall_eye = np.zeros((d1, min(d1, d2)))
|
||||
np.fill_diagonal(tall_eye, 1)
|
||||
q = tall_eye - np.dot(y_val, np.dot(t_val, y_top_val.T))
|
||||
self.assertTrue(np.allclose(np.dot(q.T, q), np.eye(min(d1, d2)))) # check that q.T * q = I
|
||||
self.assertTrue(np.allclose(np.dot(q, r_val), a_val)) # check that a = (I - y * t * y_top.T) * r
|
||||
assert_almost_equal(np.dot(q.T, q), np.eye(min(d1, d2))) # check that q.T * q = I
|
||||
assert_almost_equal(np.dot(q, r_val), a_val) # check that a = (I - y * t * y_top.T) * r
|
||||
|
||||
for d1, d2 in [(123, da.BLOCK_SIZE), (7, da.BLOCK_SIZE), (da.BLOCK_SIZE, da.BLOCK_SIZE), (da.BLOCK_SIZE, 7), (10 * da.BLOCK_SIZE, da.BLOCK_SIZE)]:
|
||||
test_dist_tsqr_hr(d1, d2)
|
||||
|
|
@ -192,11 +193,11 @@ class DistributedArrayTest(unittest.TestCase):
|
|||
a_val = ray.get(da.assemble.remote(a))
|
||||
q_val = ray.get(da.assemble.remote(q))
|
||||
r_val = ray.get(da.assemble.remote(r))
|
||||
self.assertTrue(q_val.shape == (d1, K))
|
||||
self.assertTrue(r_val.shape == (K, d2))
|
||||
self.assertTrue(np.allclose(np.dot(q_val.T, q_val), np.eye(K)))
|
||||
self.assertTrue(np.alltrue(r_val == np.triu(r_val)))
|
||||
self.assertTrue(np.allclose(a_val, np.dot(q_val, r_val)))
|
||||
self.assertEqual(q_val.shape, (d1, K))
|
||||
self.assertEqual(r_val.shape, (K, d2))
|
||||
assert_almost_equal(np.dot(q_val.T, q_val), np.eye(K))
|
||||
assert_equal(r_val, np.triu(r_val))
|
||||
assert_almost_equal(a_val, np.dot(q_val, r_val))
|
||||
|
||||
for d1, d2 in [(123, da.BLOCK_SIZE), (7, da.BLOCK_SIZE), (da.BLOCK_SIZE, da.BLOCK_SIZE), (da.BLOCK_SIZE, 7), (13, 21), (34, 35), (8, 7)]:
|
||||
test_dist_qr(d1, d2)
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ import time
|
|||
import subprocess32 as subprocess
|
||||
import os
|
||||
import sys
|
||||
from numpy.testing import assert_equal
|
||||
|
||||
import test_functions
|
||||
import ray.array.remote as ra
|
||||
|
|
@ -35,23 +36,12 @@ class SerializationTest(unittest.TestCase):
|
|||
def roundTripTest(self, data):
|
||||
serialized, _ = ray.serialization.serialize(ray.worker.global_worker.handle, data)
|
||||
result = ray.serialization.deserialize(ray.worker.global_worker.handle, serialized)
|
||||
self.assertEqual(data, result)
|
||||
assert_equal(data, result)
|
||||
|
||||
def numpyTypeTest(self, typ):
|
||||
a = np.random.randint(0, 10, size=(100, 100)).astype(typ)
|
||||
b, _ = ray.serialization.serialize(ray.worker.global_worker.handle, a)
|
||||
c = ray.serialization.deserialize(ray.worker.global_worker.handle, b)
|
||||
self.assertTrue((a == c).all())
|
||||
|
||||
a = np.array(0).astype(typ)
|
||||
b, _ = ray.serialization.serialize(ray.worker.global_worker.handle, a)
|
||||
c = ray.serialization.deserialize(ray.worker.global_worker.handle, b)
|
||||
self.assertTrue((a == c).all())
|
||||
|
||||
a = np.empty((0,)).astype(typ)
|
||||
b, _ = ray.serialization.serialize(ray.worker.global_worker.handle, a)
|
||||
c = ray.serialization.deserialize(ray.worker.global_worker.handle, b)
|
||||
self.assertEqual(a.dtype, c.dtype)
|
||||
self.roundTripTest(np.random.randint(0, 10, size=(100, 100)).astype(typ))
|
||||
self.roundTripTest(np.array(0).astype(typ))
|
||||
self.roundTripTest(np.empty((0,)).astype(typ))
|
||||
|
||||
def testSerialize(self):
|
||||
ray.init(start_ray_local=True, num_workers=0)
|
||||
|
|
@ -59,10 +49,7 @@ class SerializationTest(unittest.TestCase):
|
|||
for val in RAY_TEST_OBJECTS:
|
||||
self.roundTripTest(val)
|
||||
|
||||
a = np.zeros((100, 100))
|
||||
res, _ = ray.serialization.serialize(ray.worker.global_worker.handle, a)
|
||||
b = ray.serialization.deserialize(ray.worker.global_worker.handle, res)
|
||||
self.assertTrue((a == b).all())
|
||||
self.roundTripTest(np.zeros((100, 100)))
|
||||
|
||||
self.numpyTypeTest("int8")
|
||||
self.numpyTypeTest("uint8")
|
||||
|
|
@ -117,7 +104,7 @@ class ObjStoreTest(unittest.TestCase):
|
|||
for data in [np.zeros([10, 20]), np.random.normal(size=[45, 25])]:
|
||||
objectid = ray.put(data, w1)
|
||||
result = ray.get(objectid, w2)
|
||||
self.assertTrue(np.alltrue(result == data))
|
||||
assert_equal(result, data)
|
||||
|
||||
# This test fails. See https://github.com/amplab/ray/issues/159.
|
||||
# getting multiple times shouldn't matter
|
||||
|
|
@ -126,21 +113,21 @@ class ObjStoreTest(unittest.TestCase):
|
|||
# result = worker.get(objectid, w2)
|
||||
# result = worker.get(objectid, w2)
|
||||
# result = worker.get(objectid, w2)
|
||||
# self.assertTrue(np.alltrue(result == data))
|
||||
# assert_equal(result, data)
|
||||
|
||||
# shipping a numpy array inside something else should be fine
|
||||
data = ("a", np.random.normal(size=[10, 10]))
|
||||
objectid = ray.put(data, w1)
|
||||
result = ray.get(objectid, w2)
|
||||
self.assertEqual(data[0], result[0])
|
||||
self.assertTrue(np.alltrue(data[1] == result[1]))
|
||||
assert_equal(data[1], result[1])
|
||||
|
||||
# shipping a numpy array inside something else should be fine
|
||||
data = ["a", np.random.normal(size=[10, 10])]
|
||||
objectid = ray.put(data, w1)
|
||||
result = ray.get(objectid, w2)
|
||||
self.assertEqual(data[0], result[0])
|
||||
self.assertTrue(np.alltrue(data[1] == result[1]))
|
||||
assert_equal(data[1], result[1])
|
||||
|
||||
# Getting a buffer after modifying it before it finishes should return updated buffer
|
||||
objectid = ray.libraylib.get_objectid(w1.handle)
|
||||
|
|
@ -193,11 +180,11 @@ class APITest(unittest.TestCase):
|
|||
ray.init(start_ray_local=True, num_workers=3, driver_mode=ray.SILENT_MODE)
|
||||
|
||||
ref = test_functions.test_alias_f.remote()
|
||||
self.assertTrue(np.alltrue(ray.get(ref) == np.ones([3, 4, 5])))
|
||||
assert_equal(ray.get(ref), np.ones([3, 4, 5]))
|
||||
ref = test_functions.test_alias_g.remote()
|
||||
self.assertTrue(np.alltrue(ray.get(ref) == np.ones([3, 4, 5])))
|
||||
assert_equal(ray.get(ref), np.ones([3, 4, 5]))
|
||||
ref = test_functions.test_alias_h.remote()
|
||||
self.assertTrue(np.alltrue(ray.get(ref) == np.ones([3, 4, 5])))
|
||||
assert_equal(ray.get(ref), np.ones([3, 4, 5]))
|
||||
|
||||
ray.worker.cleanup()
|
||||
|
||||
|
|
@ -315,7 +302,7 @@ class APITest(unittest.TestCase):
|
|||
@ray.remote([], [np.ndarray])
|
||||
def h():
|
||||
return np.zeros([3, 5])
|
||||
self.assertTrue(np.alltrue(ray.get(h.remote()) == np.zeros([3, 5])))
|
||||
assert_equal(ray.get(h.remote()), np.zeros([3, 5]))
|
||||
@ray.remote([], [float])
|
||||
def j():
|
||||
return time.time()
|
||||
|
|
@ -485,7 +472,7 @@ class ReferenceCountingTest(unittest.TestCase):
|
|||
# objectid = ray.put(data)
|
||||
# result = worker.get(objectid)
|
||||
# result = worker.get(objectid)
|
||||
# self.assertTrue(np.alltrue(result == data))
|
||||
# assert_equal(result, data)
|
||||
|
||||
ray.worker.cleanup()
|
||||
|
||||
|
|
@ -512,18 +499,18 @@ class PythonModeTest(unittest.TestCase):
|
|||
ray.init(start_ray_local=True, driver_mode=ray.PYTHON_MODE)
|
||||
|
||||
xref = test_functions.test_alias_h.remote()
|
||||
self.assertTrue(np.alltrue(xref == np.ones([3, 4, 5]))) # remote functions should return by value
|
||||
self.assertTrue(np.alltrue(xref == ray.get(xref))) # ray.get should be the identity
|
||||
assert_equal(xref, np.ones([3, 4, 5])) # remote functions should return by value
|
||||
assert_equal(xref, ray.get(xref)) # ray.get should be the identity
|
||||
y = np.random.normal(size=[11, 12])
|
||||
self.assertTrue(np.alltrue(y == ray.put(y))) # ray.put should be the identity
|
||||
assert_equal(y, ray.put(y)) # ray.put should be the identity
|
||||
|
||||
# make sure objects are immutable, this example is why we need to copy
|
||||
# arguments before passing them into remote functions in python mode
|
||||
aref = test_functions.python_mode_f.remote()
|
||||
self.assertTrue(np.alltrue(aref == np.array([0, 0])))
|
||||
assert_equal(aref, np.array([0, 0]))
|
||||
bref = test_functions.python_mode_g.remote(aref)
|
||||
self.assertTrue(np.alltrue(aref == np.array([0, 0]))) # python_mode_g should not mutate aref
|
||||
self.assertTrue(np.alltrue(bref == np.array([1, 0])))
|
||||
assert_equal(aref, np.array([0, 0])) # python_mode_g should not mutate aref
|
||||
assert_equal(bref, np.array([1, 0]))
|
||||
|
||||
ray.worker.cleanup()
|
||||
|
||||
|
|
@ -596,10 +583,10 @@ class ReusablesTest(unittest.TestCase):
|
|||
baz = ray.reusables.baz
|
||||
baz[i] = 1
|
||||
return baz
|
||||
self.assertTrue(np.alltrue(ray.get(use_baz.remote(0)) == np.array([1, 0, 0, 0])))
|
||||
self.assertTrue(np.alltrue(ray.get(use_baz.remote(1)) == np.array([0, 1, 0, 0])))
|
||||
self.assertTrue(np.alltrue(ray.get(use_baz.remote(2)) == np.array([0, 0, 1, 0])))
|
||||
self.assertTrue(np.alltrue(ray.get(use_baz.remote(3)) == np.array([0, 0, 0, 1])))
|
||||
assert_equal(ray.get(use_baz.remote(0)), np.array([1, 0, 0, 0]))
|
||||
assert_equal(ray.get(use_baz.remote(1)), np.array([0, 1, 0, 0]))
|
||||
assert_equal(ray.get(use_baz.remote(2)), np.array([0, 0, 1, 0]))
|
||||
assert_equal(ray.get(use_baz.remote(3)), np.array([0, 0, 0, 1]))
|
||||
|
||||
# Make sure the reinitializer is actually getting called. Note that this is
|
||||
# not the correct usage of a reinitializer because it does not reset qux to
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue