Remove type information from remote decorator.

lib/python/ray/array/distributed/core.py

@@ -66,12 +66,12 @@ class DistArray(object):
     a = self.assemble()
     return a[sliced]
 
-@ray.remote([DistArray], [np.ndarray])
+@ray.remote()
 def assemble(a):
   return a.assemble()
 
 # TODO(rkn): what should we call this method
-@ray.remote([np.ndarray], [DistArray])
+@ray.remote()
 def numpy_to_dist(a):
   result = DistArray(a.shape)
   for index in np.ndindex(*result.num_blocks):
@@ -80,28 +80,28 @@ def numpy_to_dist(a):
     result.objectids[index] = ray.put(a[[slice(l, u) for (l, u) in zip(lower, upper)]])
   return result
 
-@ray.remote([List, str], [DistArray])
+@ray.remote()
 def zeros(shape, dtype_name="float"):
   result = DistArray(shape)
   for index in np.ndindex(*result.num_blocks):
     result.objectids[index] = ra.zeros.remote(DistArray.compute_block_shape(index, shape), dtype_name=dtype_name)
   return result
 
-@ray.remote([List, str], [DistArray])
+@ray.remote()
 def ones(shape, dtype_name="float"):
   result = DistArray(shape)
   for index in np.ndindex(*result.num_blocks):
     result.objectids[index] = ra.ones.remote(DistArray.compute_block_shape(index, shape), dtype_name=dtype_name)
   return result
 
-@ray.remote([DistArray], [DistArray])
+@ray.remote()
 def copy(a):
   result = DistArray(a.shape)
   for index in np.ndindex(*result.num_blocks):
     result.objectids[index] = a.objectids[index] # We don't need to actually copy the objects because cluster-level objects are assumed to be immutable.
   return result
 
-@ray.remote([int, int, str], [DistArray])
+@ray.remote()
 def eye(dim1, dim2=-1, dtype_name="float"):
   dim2 = dim1 if dim2 == -1 else dim2
   shape = [dim1, dim2]
@@ -114,7 +114,7 @@ def eye(dim1, dim2=-1, dtype_name="float"):
       result.objectids[i, j] = ra.zeros.remote(block_shape, dtype_name=dtype_name)
   return result
 
-@ray.remote([DistArray], [DistArray])
+@ray.remote()
 def triu(a):
   if a.ndim != 2:
     raise Exception("Input must have 2 dimensions, but a.ndim is " + str(a.ndim))
@@ -128,7 +128,7 @@ def triu(a):
       result.objectids[i, j] = ra.zeros_like.remote(a.objectids[i, j])
   return result
 
-@ray.remote([DistArray], [DistArray])
+@ray.remote()
 def tril(a):
   if a.ndim != 2:
     raise Exception("Input must have 2 dimensions, but a.ndim is " + str(a.ndim))
@@ -142,7 +142,7 @@ def tril(a):
       result.objectids[i, j] = ra.zeros_like.remote(a.objectids[i, j])
   return result
 
-@ray.remote([np.ndarray], [np.ndarray])
+@ray.remote()
 def blockwise_dot(*matrices):
   n = len(matrices)
   if n % 2 != 0:
@@ -153,7 +153,7 @@ def blockwise_dot(*matrices):
     result += np.dot(matrices[i], matrices[n / 2 + i])
   return result
 
-@ray.remote([DistArray, DistArray], [DistArray])
+@ray.remote()
 def dot(a, b):
   if a.ndim != 2:
     raise Exception("dot expects its arguments to be 2-dimensional, but a.ndim = {}.".format(a.ndim))
@@ -168,7 +168,7 @@ def dot(a, b):
     result.objectids[i, j] = blockwise_dot.remote(*args)
   return result
 
-@ray.remote([DistArray, List], [DistArray])
+@ray.remote()
 def subblocks(a, *ranges):
   """
   This function produces a distributed array from a subset of the blocks in the `a`. The result and `a` will have the same number of dimensions.For example,
@@ -198,7 +198,7 @@ def subblocks(a, *ranges):
     result.objectids[index] = a.objectids[tuple([ranges[i][index[i]] for i in range(a.ndim)])]
   return result
 
-@ray.remote([DistArray], [DistArray])
+@ray.remote()
 def transpose(a):
   if a.ndim != 2:
     raise Exception("transpose expects its argument to be 2-dimensional, but a.ndim = {}, a.shape = {}.".format(a.ndim, a.shape))
@@ -209,7 +209,7 @@ def transpose(a):
   return result
 
 # TODO(rkn): support broadcasting?
-@ray.remote([DistArray, DistArray], [DistArray])
+@ray.remote()
 def add(x1, x2):
   if x1.shape != x2.shape:
     raise Exception("add expects arguments `x1` and `x2` to have the same shape, but x1.shape = {}, and x2.shape = {}.".format(x1.shape, x2.shape))
@@ -219,7 +219,7 @@ def add(x1, x2):
   return result
 
 # TODO(rkn): support broadcasting?
-@ray.remote([DistArray, DistArray], [DistArray])
+@ray.remote()
 def subtract(x1, x2):
   if x1.shape != x2.shape:
     raise Exception("subtract expects arguments `x1` and `x2` to have the same shape, but x1.shape = {}, and x2.shape = {}.".format(x1.shape, x2.shape))

lib/python/ray/array/distributed/linalg.py

@@ -6,7 +6,7 @@ from core import *
 
 __all__ = ["tsqr", "modified_lu", "tsqr_hr", "qr"]
 
-@ray.remote([DistArray], [DistArray, np.ndarray])
+@ray.remote(num_return_vals=2)
 def tsqr(a):
   """
   arguments:
@@ -75,7 +75,7 @@ def tsqr(a):
   return q_result, r
 
 # TODO(rkn): This is unoptimized, we really want a block version of this.
-@ray.remote([DistArray], [DistArray, np.ndarray, np.ndarray])
+@ray.remote(num_return_vals=3)
 def modified_lu(q):
   """
   Algorithm 5 from http://www.eecs.berkeley.edu/Pubs/TechRpts/2013/EECS-2013-175.pdf
@@ -105,19 +105,19 @@ def modified_lu(q):
   U = np.triu(q_work)[:b, :]
   return numpy_to_dist.remote(ray.put(L)), U, S # TODO(rkn): get rid of put
 
-@ray.remote([np.ndarray, np.ndarray, np.ndarray, int], [np.ndarray, np.ndarray])
+@ray.remote(num_return_vals=2)
 def tsqr_hr_helper1(u, s, y_top_block, b):
   y_top = y_top_block[:b, :b]
   s_full = np.diag(s)
   t = -1 * np.dot(u, np.dot(s_full, np.linalg.inv(y_top).T))
   return t, y_top
 
-@ray.remote([np.ndarray, np.ndarray], [np.ndarray])
+@ray.remote()
 def tsqr_hr_helper2(s, r_temp):
   s_full = np.diag(s)
   return np.dot(s_full, r_temp)
 
-@ray.remote([DistArray], [DistArray, np.ndarray, np.ndarray, np.ndarray])
+@ray.remote(num_return_vals=4)
 def tsqr_hr(a):
   """Algorithm 6 from http://www.eecs.berkeley.edu/Pubs/TechRpts/2013/EECS-2013-175.pdf"""
   q, r_temp = tsqr.remote(a)
@@ -127,15 +127,15 @@ def tsqr_hr(a):
   r = tsqr_hr_helper2.remote(s, r_temp)
   return y, t, y_top, r
 
-@ray.remote([np.ndarray, np.ndarray, np.ndarray, np.ndarray], [np.ndarray])
+@ray.remote()
 def qr_helper1(a_rc, y_ri, t, W_c):
   return a_rc - np.dot(y_ri, np.dot(t.T, W_c))
 
-@ray.remote([np.ndarray, np.ndarray], [np.ndarray])
+@ray.remote()
 def qr_helper2(y_ri, a_rc):
   return np.dot(y_ri.T, a_rc)
 
-@ray.remote([DistArray], [DistArray, DistArray])
+@ray.remote(num_return_vals=2)
 def qr(a):
   """Algorithm 7 from http://www.eecs.berkeley.edu/Pubs/TechRpts/2013/EECS-2013-175.pdf"""
   m, n = a.shape[0], a.shape[1]

lib/python/ray/array/distributed/random.py

@@ -6,7 +6,7 @@ import ray
 
 from core import *
 
-@ray.remote([List], [DistArray])
+@ray.remote()
 def normal(shape):
   num_blocks = DistArray.compute_num_blocks(shape)
   objectids = np.empty(num_blocks, dtype=object)

lib/python/ray/array/remote/core.py

@@ -4,80 +4,80 @@ import ray
 
 __all__ = ["zeros", "zeros_like", "ones", "eye", "dot", "vstack", "hstack", "subarray", "copy", "tril", "triu", "diag", "transpose", "add", "subtract", "sum", "shape", "sum_list"]
 
-@ray.remote([List, str, str], [np.ndarray])
+@ray.remote()
 def zeros(shape, dtype_name="float", order="C"):
   return np.zeros(shape, dtype=np.dtype(dtype_name), order=order)
 
-@ray.remote([np.ndarray, str, str, bool], [np.ndarray])
+@ray.remote()
 def zeros_like(a, dtype_name="None", order="K", subok=True):
   dtype_val = None if dtype_name == "None" else np.dtype(dtype_name)
   return np.zeros_like(a, dtype=dtype_val, order=order, subok=subok)
 
-@ray.remote([List, str, str], [np.ndarray])
+@ray.remote()
 def ones(shape, dtype_name="float", order="C"):
   return np.ones(shape, dtype=np.dtype(dtype_name), order=order)
 
-@ray.remote([int, int, int, str], [np.ndarray])
+@ray.remote()
 def eye(N, M=-1, k=0, dtype_name="float"):
   M = N if M == -1 else M
   return np.eye(N, M=M, k=k, dtype=np.dtype(dtype_name))
 
-@ray.remote([np.ndarray, np.ndarray], [np.ndarray])
+@ray.remote()
 def dot(a, b):
   return np.dot(a, b)
 
-@ray.remote([np.ndarray], [np.ndarray])
+@ray.remote()
 def vstack(*xs):
   return np.vstack(xs)
 
-@ray.remote([np.ndarray], [np.ndarray])
+@ray.remote()
 def hstack(*xs):
   return np.hstack(xs)
 
 # TODO(rkn): instead of this, consider implementing slicing
-@ray.remote([np.ndarray, List, List], [np.ndarray])
+@ray.remote()
 def subarray(a, lower_indices, upper_indices): # TODO(rkn): be consistent about using "index" versus "indices"
   return a[[slice(l, u) for (l, u) in zip(lower_indices, upper_indices)]]
 
-@ray.remote([np.ndarray, str], [np.ndarray])
+@ray.remote()
 def copy(a, order="K"):
   return np.copy(a, order=order)
 
-@ray.remote([np.ndarray, int], [np.ndarray])
+@ray.remote()
 def tril(m, k=0):
   return np.tril(m, k=k)
 
-@ray.remote([np.ndarray, int], [np.ndarray])
+@ray.remote()
 def triu(m, k=0):
   return np.triu(m, k=k)
 
-@ray.remote([np.ndarray, int], [np.ndarray])
+@ray.remote()
 def diag(v, k=0):
   return np.diag(v, k=k)
 
-@ray.remote([np.ndarray, List], [np.ndarray])
+@ray.remote()
 def transpose(a, axes=[]):
   axes = None if axes == [] else axes
   return np.transpose(a, axes=axes)
 
-@ray.remote([np.ndarray, np.ndarray], [np.ndarray])
+@ray.remote()
 def add(x1, x2):
   return np.add(x1, x2)
 
-@ray.remote([np.ndarray, np.ndarray], [np.ndarray])
+@ray.remote()
 def subtract(x1, x2):
   return np.subtract(x1, x2)
 
-@ray.remote([np.ndarray, int], [np.ndarray])
+@ray.remote()
 def sum(x, axis=-1):
   return np.sum(x, axis=axis if axis != -1 else None)
 
-@ray.remote([np.ndarray], [tuple])
+@ray.remote()
 def shape(a):
   return np.shape(a)
 
 # We use Any to allow different numerical types as well as numpy arrays.
 # TODO(rkn):this isn't in the numpy API, so be careful about exposing this.
-@ray.remote([Any], [Any])
+@ray.remote()
 def sum_list(*xs):
   return np.sum(xs, axis=0)

lib/python/ray/array/remote/linalg.py

@@ -7,82 +7,82 @@ __all__ = ["matrix_power", "solve", "tensorsolve", "tensorinv", "inv",
            "svd", "eig", "eigh", "lstsq", "norm", "qr", "cond", "matrix_rank",
            "LinAlgError", "multi_dot"]
 
-@ray.remote([np.ndarray, int], [np.ndarray])
+@ray.remote()
 def matrix_power(M, n):
   return np.linalg.matrix_power(M, n)
 
-@ray.remote([np.ndarray, np.ndarray], [np.ndarray])
+@ray.remote()
 def solve(a, b):
   return np.linalg.solve(a, b)
 
-@ray.remote([np.ndarray], [np.ndarray, np.ndarray])
+@ray.remote(num_return_vals=2)
 def tensorsolve(a):
   raise NotImplementedError
 
-@ray.remote([np.ndarray], [np.ndarray, np.ndarray])
+@ray.remote(num_return_vals=2)
 def tensorinv(a):
   raise NotImplementedError
 
-@ray.remote([np.ndarray], [np.ndarray])
+@ray.remote()
 def inv(a):
   return np.linalg.inv(a)
 
-@ray.remote([np.ndarray], [np.ndarray])
+@ray.remote()
 def cholesky(a):
   return np.linalg.cholesky(a)
 
-@ray.remote([np.ndarray], [np.ndarray])
+@ray.remote()
 def eigvals(a):
   return np.linalg.eigvals(a)
 
-@ray.remote([np.ndarray], [np.ndarray])
+@ray.remote()
 def eigvalsh(a):
   raise NotImplementedError
 
-@ray.remote([np.ndarray], [np.ndarray])
+@ray.remote()
 def pinv(a):
   return np.linalg.pinv(a)
 
-@ray.remote([np.ndarray], [int])
+@ray.remote()
 def slogdet(a):
   raise NotImplementedError
 
-@ray.remote([np.ndarray], [float])
+@ray.remote()
 def det(a):
   return np.linalg.det(a)
 
-@ray.remote([np.ndarray], [np.ndarray, np.ndarray, np.ndarray])
+@ray.remote(num_return_vals=3)
 def svd(a):
   return np.linalg.svd(a)
 
-@ray.remote([np.ndarray], [np.ndarray, np.ndarray])
+@ray.remote(num_return_vals=2)
 def eig(a):
   return np.linalg.eig(a)
 
-@ray.remote([np.ndarray], [np.ndarray, np.ndarray])
+@ray.remote(num_return_vals=2)
 def eigh(a):
   return np.linalg.eigh(a)
 
-@ray.remote([np.ndarray], [np.ndarray, np.ndarray, int, np.ndarray])
+@ray.remote(num_return_vals=4)
 def lstsq(a, b):
   return np.linalg.lstsq(a)
 
-@ray.remote([np.ndarray], [float])
+@ray.remote()
 def norm(x):
   return np.linalg.norm(x)
 
-@ray.remote([np.ndarray], [np.ndarray, np.ndarray])
+@ray.remote(num_return_vals=2)
 def qr(a):
   return np.linalg.qr(a)
 
-@ray.remote([np.ndarray], [float])
+@ray.remote()
 def cond(x):
   return np.linalg.cond(x)
 
-@ray.remote([np.ndarray], [int])
+@ray.remote()
 def matrix_rank(M):
   return np.linalg.matrix_rank(M)
 
-@ray.remote([np.ndarray], [np.ndarray])
+@ray.remote()
 def multi_dot(*a):
   raise NotImplementedError

lib/python/ray/array/remote/random.py

@@ -2,6 +2,6 @@ from typing import List
 import numpy as np
 import ray
 
-@ray.remote([List], [np.ndarray])
+@ray.remote()
 def normal(shape):
   return np.random.normal(size=shape)