Add files using upload-large-folder tool

.venv/lib/python3.11/site-packages/ray/experimental/array/remote/__init__.py

@@ -0,0 +1,44 @@
+from . import linalg, random
+from .core import (
+    add,
+    copy,
+    diag,
+    dot,
+    eye,
+    hstack,
+    ones,
+    shape,
+    subarray,
+    subtract,
+    sum,
+    sum_list,
+    transpose,
+    tril,
+    triu,
+    vstack,
+    zeros,
+    zeros_like,
+)
+
+__all__ = [
+    "random",
+    "linalg",
+    "zeros",
+    "zeros_like",
+    "ones",
+    "eye",
+    "dot",
+    "vstack",
+    "hstack",
+    "subarray",
+    "copy",
+    "tril",
+    "triu",
+    "diag",
+    "transpose",
+    "add",
+    "subtract",
+    "sum",
+    "shape",
+    "sum_list",
+]

.venv/lib/python3.11/site-packages/ray/experimental/array/remote/core.py

@@ -0,0 +1,99 @@
+import numpy as np
+
+import ray
+
+
+@ray.remote
+def zeros(shape, dtype_name="float", order="C"):
+    return np.zeros(shape, dtype=np.dtype(dtype_name), order=order)
+
+
+@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
+def ones(shape, dtype_name="float", order="C"):
+    return np.ones(shape, dtype=np.dtype(dtype_name), order=order)
+
+
+@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
+def dot(a, b):
+    return np.dot(a, b)
+
+
+@ray.remote
+def vstack(*xs):
+    return np.vstack(xs)
+
+
+@ray.remote
+def hstack(*xs):
+    return np.hstack(xs)
+
+
+# TODO(rkn): Instead of this, consider implementing slicing.
+# TODO(rkn): Be consistent about using "index" versus "indices".
+@ray.remote
+def subarray(a, lower_indices, upper_indices):
+    idx = tuple(slice(l, u) for (l, u) in zip(lower_indices, upper_indices))
+    return a[idx]
+
+
+@ray.remote
+def copy(a, order="K"):
+    return np.copy(a, order=order)
+
+
+@ray.remote
+def tril(m, k=0):
+    return np.tril(m, k=k)
+
+
+@ray.remote
+def triu(m, k=0):
+    return np.triu(m, k=k)
+
+
+@ray.remote
+def diag(v, k=0):
+    return np.diag(v, k=k)
+
+
+@ray.remote
+def transpose(a, axes=None):
+    axes = None if (axes == [] or axes is None) else axes
+    return np.transpose(a, axes=axes)
+
+
+@ray.remote
+def add(x1, x2):
+    return np.add(x1, x2)
+
+
+@ray.remote
+def subtract(x1, x2):
+    return np.subtract(x1, x2)
+
+
+@ray.remote
+def sum(x, axis=-1):
+    return np.sum(x, axis=axis if axis != -1 else None)
+
+
+@ray.remote
+def shape(a):
+    return np.shape(a)
+
+
+@ray.remote
+def sum_list(*xs):
+    return np.sum(xs, axis=0)

.venv/lib/python3.11/site-packages/ray/experimental/array/remote/linalg.py

@@ -0,0 +1,126 @@
+import numpy as np
+
+import ray
+
+__all__ = [
+    "matrix_power",
+    "solve",
+    "tensorsolve",
+    "tensorinv",
+    "inv",
+    "cholesky",
+    "eigvals",
+    "eigvalsh",
+    "pinv",
+    "slogdet",
+    "det",
+    "svd",
+    "eig",
+    "eigh",
+    "lstsq",
+    "norm",
+    "qr",
+    "cond",
+    "matrix_rank",
+    "multi_dot",
+]
+
+
+@ray.remote
+def matrix_power(M, n):
+    return np.linalg.matrix_power(M, n)
+
+
+@ray.remote
+def solve(a, b):
+    return np.linalg.solve(a, b)
+
+
+@ray.remote(num_returns=2)
+def tensorsolve(a):
+    raise NotImplementedError
+
+
+@ray.remote(num_returns=2)
+def tensorinv(a):
+    raise NotImplementedError
+
+
+@ray.remote
+def inv(a):
+    return np.linalg.inv(a)
+
+
+@ray.remote
+def cholesky(a):
+    return np.linalg.cholesky(a)
+
+
+@ray.remote
+def eigvals(a):
+    return np.linalg.eigvals(a)
+
+
+@ray.remote
+def eigvalsh(a):
+    raise NotImplementedError
+
+
+@ray.remote
+def pinv(a):
+    return np.linalg.pinv(a)
+
+
+@ray.remote
+def slogdet(a):
+    raise NotImplementedError
+
+
+@ray.remote
+def det(a):
+    return np.linalg.det(a)
+
+
+@ray.remote(num_returns=3)
+def svd(a):
+    return np.linalg.svd(a)
+
+
+@ray.remote(num_returns=2)
+def eig(a):
+    return np.linalg.eig(a)
+
+
+@ray.remote(num_returns=2)
+def eigh(a):
+    return np.linalg.eigh(a)
+
+
+@ray.remote(num_returns=4)
+def lstsq(a, b):
+    return np.linalg.lstsq(a)
+
+
+@ray.remote
+def norm(x):
+    return np.linalg.norm(x)
+
+
+@ray.remote(num_returns=2)
+def qr(a):
+    return np.linalg.qr(a)
+
+
+@ray.remote
+def cond(x):
+    return np.linalg.cond(x)
+
+
+@ray.remote
+def matrix_rank(M):
+    return np.linalg.matrix_rank(M)
+
+
+@ray.remote
+def multi_dot(*a):
+    raise NotImplementedError

.venv/lib/python3.11/site-packages/ray/experimental/array/remote/random.py

@@ -0,0 +1,8 @@
+import numpy as np
+
+import ray
+
+
+@ray.remote
+def normal(shape):
+    return np.random.normal(size=shape)

.venv/lib/python3.11/site-packages/ray/experimental/dynamic_resources.py

@@ -0,0 +1,7 @@
+def set_resource(resource_name, capacity, node_id=None):
+    raise DeprecationWarning(
+        "Dynamic custom resources are deprecated. Consider using placement "
+        "groups instead (docs.ray.io/en/master/placement-group.html). You "
+        "can also specify resources at Ray start time with the 'resources' "
+        "field in the cluster autoscaler."
+    )

.venv/lib/python3.11/site-packages/ray/experimental/job/example_job/demo_script.py

@@ -0,0 +1,77 @@
+# Regular ray application that user wrote and runs on local cluster.
+# intermediate status are dumped to GCS
+import argparse
+import time
+
+import ray
+import ray.experimental.internal_kv as ray_kv
+
+
+@ray.remote
+class StepActor:
+    def __init__(self, interval_s=1, total_steps=3):
+        self.interval_s = interval_s
+        self.stopped = False
+        self.current_step = 1
+        self.total_steps = total_steps
+
+        worker = ray._private.worker.global_worker
+        worker_id = worker.core_worker.get_actor_id()
+        ray_kv._internal_kv_put(f"JOB:{worker_id}", self.current_step, overwrite=True)
+
+    def run(self):
+        worker = ray._private.worker.global_worker
+        worker_id = worker.core_worker.get_actor_id()
+
+        while self.current_step <= self.total_steps:
+            if not self.stopped:
+                print(
+                    f"Sleeping {self.interval_s} secs to executing "
+                    f"step {self.current_step}"
+                )
+                time.sleep(self.interval_s)
+                self.current_step += 1
+                ray_kv._internal_kv_put(
+                    f"JOB:{worker_id}", self.current_step, overwrite=True
+                )
+            else:
+                print("Stop called or reached final step.")
+                break
+
+        self.stopped = True
+        ray_kv._internal_kv_put(f"JOB:{worker_id}", "DONE", overwrite=True)
+        return "DONE"
+
+    def get_step(self):
+        return self.current_step
+
+    def stop(self):
+        self.stopped = True
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--interval-s",
+        required=False,
+        type=int,
+        default=1,
+        help="Address to use to connect to Ray",
+    )
+    parser.add_argument(
+        "--total-steps",
+        required=False,
+        type=int,
+        default=3,
+        help="Password for connecting to Redis",
+    )
+    args, _ = parser.parse_known_args()
+
+    ray.init()
+    step_actor = StepActor.remote(
+        interval_s=args.interval_s, total_steps=args.total_steps
+    )
+    ref = step_actor.run.remote()
+    print(ray.get([ref]))
+    job_key = ray_kv._internal_kv_list("JOB:")[0]
+    print(f"{job_key}, {ray_kv._internal_kv_get(job_key)}")

.venv/lib/python3.11/site-packages/ray/experimental/multiprocessing/__init__.py

@@ -0,0 +1,5 @@
+from multiprocessing import TimeoutError
+
+from .pool import Pool
+
+__all__ = ["Pool", "TimeoutError"]