Continue the work on Promises and PromiseTensors

syft/__init__.py

@@ -54,6 +54,7 @@
 from syft.messaging.plan import Plan
 from syft.messaging.plan import func2plan
 from syft.messaging.plan import method2plan
+from syft.messaging.promise import Promise
 
 # Import Worker Types
 from syft.workers.virtual import VirtualWorker
@@ -67,6 +68,7 @@
 from syft.frameworks.torch.tensors.interpreters.autograd import AutogradTensor
 from syft.frameworks.torch.tensors.interpreters.precision import FixedPrecisionTensor
 from syft.frameworks.torch.tensors.interpreters.large_precision import LargePrecisionTensor
+from syft.frameworks.torch.tensors.interpreters.promise import PromiseTensor
 from syft.generic.pointers.pointer_plan import PointerPlan
 from syft.generic.pointers.pointer_protocol import PointerProtocol
 from syft.generic.pointers.pointer_tensor import PointerTensor

syft/frameworks/torch/hook/hook.py

@@ -10,9 +10,11 @@
 import syft
 from syft.generic.frameworks.hook import hook_args
 from syft.generic.frameworks.hook.hook import FrameworkHook
+from syft.generic.tensor import AbstractTensor
 from syft.generic.frameworks.remote import Remote
 from syft.frameworks.torch.tensors.interpreters.autograd import AutogradTensor
 from syft.frameworks.torch.tensors.interpreters.native import TorchTensor
+from syft.frameworks.torch.tensors.interpreters.promise import PromiseTensor
 from syft.frameworks.torch.tensors.interpreters.paillier import PaillierTensor
 from syft.frameworks.torch.tensors.decorators.logging import LoggingTensor
 from syft.frameworks.torch.tensors.interpreters.precision import FixedPrecisionTensor
@@ -26,6 +28,7 @@
 from syft.workers.base import BaseWorker
 from syft.workers.virtual import VirtualWorker
 from syft.messaging.plan import Plan
+from syft.messaging.promise import Promise
 
 from syft.exceptions import route_method_exception
 from syft.exceptions import TensorsNotCollocatedException
@@ -168,6 +171,9 @@ def __init__(
         # Add all hooked tensor methods to LargePrecisionTensor tensor
         self._hook_syft_tensor_methods(LargePrecisionTensor)
 
+        # Add all hooked tensor methods to PromiseTensor
+        self._hook_promise_tensor()
+
         # Hook the tensor constructor function
         self._hook_tensor()
 
@@ -504,6 +510,103 @@ def overloaded_attr(self, *args, **kwargs):
 
         return overloaded_attr
 
+    def _hook_promise_tensor(hook_self):
+
+        methods_to_hook = hook_self.to_auto_overload[torch.Tensor]
+
+        def generate_method(method_name):
+            def method(self, *args, **kwargs):
+
+                arg_shapes = list([self.shape])
+                arg_ids = list([self.id])
+
+                # Convert scalar arguments to tensors to be able to use them with plans
+                args = list(args)
+                for ia in range(len(args)):
+                    if not isinstance(args[ia], (torch.Tensor, AbstractTensor)):
+                        args[ia] = torch.tensor(args[ia])
+
+                for arg in args:
+                    arg_shapes.append(arg.shape)
+
+                @syft.func2plan(arg_shapes)
+                def operation_method(self, *args, **kwargs):
+                    return getattr(self, method_name)(*args, **kwargs)
+
+                self.plans.add(operation_method.id)
+                for arg in args:
+                    if isinstance(arg, PromiseTensor):
+                        arg.plans.add(operation_method.id)
+
+                operation_method.procedure.update_args(
+                    [self, *args], operation_method.procedure.result_ids
+                )
+
+                promise_out = PromiseTensor(
+                    owner=self.owner,
+                    shape=operation_method.output_shape,
+                    tensor_type=self.obj_type,
+                    plans=set(),
+                )
+                operation_method.procedure.promise_out_id = promise_out.id
+
+                if operation_method.owner != self.owner:
+                    operation_method.send(self.owner)
+                else:  # otherwise object not registered on local worker
+                    operation_method.owner.register_obj(operation_method)
+
+                return promise_out
+
+            return method
+
+        for method_name in methods_to_hook:
+            setattr(PromiseTensor, method_name, generate_method(method_name))
+
+        def FloatTensor(shape, *args, **kwargs):
+            return PromiseTensor(shape, tensor_type="torch.FloatTensor", *args, **kwargs).wrap()
+
+        setattr(Promise, "FloatTensor", FloatTensor)
+
+        def DoubleTensor(shape, *args, **kwargs):
+            return PromiseTensor(shape, tensor_type="torch.DoubleTensor", *args, **kwargs).wrap()
+
+        setattr(Promise, "DoubleTensor", DoubleTensor)
+
+        def HalfTensor(shape, *args, **kwargs):
+            return PromiseTensor(shape, tensor_type="torch.HalfTensor", *args, **kwargs).wrap()
+
+        setattr(Promise, "HalfTensor", HalfTensor)
+
+        def ByteTensor(shape, *args, **kwargs):
+            return PromiseTensor(shape, tensor_type="torch.ByteTensor", *args, **kwargs).wrap()
+
+        setattr(Promise, "ByteTensor", ByteTensor)
+
+        def CharTensor(shape, *args, **kwargs):
+            return PromiseTensor(shape, tensor_type="torch.CharTensor", *args, **kwargs).wrap()
+
+        setattr(Promise, "CharTensor", CharTensor)
+
+        def ShortTensor(shape, *args, **kwargs):
+            return PromiseTensor(shape, tensor_type="torch.ShortTensor", *args, **kwargs).wrap()
+
+        setattr(Promise, "ShortTensor", ShortTensor)
+
+        def IntTensor(shape, *args, **kwargs):
+            return PromiseTensor(shape, tensor_type="torch.IntTensor", *args, **kwargs).wrap()
+
+        setattr(Promise, "IntTensor", IntTensor)
+
+        def LongTensor(shape, *args, **kwargs):
+            return PromiseTensor(shape, tensor_type="torch.LongTensor", *args, **kwargs).wrap()
+
+        setattr(Promise, "LongTensor", LongTensor)
+
+        def BoolTensor(shape, args, **kwargs):
+            return PromiseTensor(shape, tensor_type="torch.BoolTensor", *args, **kwargs).wrap()
+
+        setattr(Promise, "BoolTensor", BoolTensor)
+
     def _hook_tensor(hook_self):
         """Hooks the function torch.tensor()
         We need to do this seperately from hooking the class because internally

syft/frameworks/torch/tensors/interpreters/__init__.py

@@ -0,0 +1 @@
+

syft/frameworks/torch/tensors/interpreters/native.py

@@ -11,6 +11,7 @@
 from syft.generic.frameworks.hook import hook_args
 from syft.generic.frameworks.overload import overloaded
 from syft.frameworks.torch.tensors.interpreters.crt_precision import _moduli_for_fields
+from syft.frameworks.torch.tensors.interpreters.promise import PromiseTensor
 from syft.frameworks.torch.tensors.interpreters.paillier import PaillierTensor
 from syft.generic.frameworks.types import FrameworkTensor
 from syft.generic.tensor import AbstractTensor
@@ -583,6 +584,10 @@ def move(self, location):
         self.child.owner.register_obj(self)
         return self
 
+    def remote_send(self, location, change_location=False):
+        self.child.remote_send(location, change_location)
+        return self
+
     def attr(self, attr_name):
         """"""
 
@@ -814,6 +819,25 @@ def combine(self, *pointers):
 
         return syft.combine_pointers(*ps)
 
+    def keep(self, obj):
+        """ Call .keep() on self's child if the child is a Promise (otherwise an error is raised).
+        .keep() is used to fulfill a promise with a value.
+        """
+        return self.child.keep(obj)
+
+    def value(self):
+        """ Call .value() on self's child if the child is a Promise (otherwise an error is raised).
+        .value() is used to retrieve the oldest unused value the promise was kept with.
+        """
+        return self.child.value()
+
+    def torch_type(self):
+
+        if isinstance(self, torch.Tensor) and not self.is_wrapper:
+            return self.type()
+        else:
+            return self.child.torch_type()
+
     def encrypt(self, public_key):
         """This method will encrypt each value in the tensor using Paillier
         homomorphic encryption.

syft/frameworks/torch/tensors/interpreters/promise.py

@@ -0,0 +1,110 @@
+import syft as sy
+from syft.workers.abstract import AbstractWorker
+import weakref
+
+from syft.generic.tensor import AbstractTensor
+from syft.generic.tensor import initialize_tensor
+from syft.messaging.promise import Promise
+from syft.generic.frameworks.hook import hook_args
+
+
+class PromiseTensor(AbstractTensor, Promise):
+    def __init__(
+        self, shape, owner=None, id=None, tensor_type=None, plans=None, tags=None, description=None,
+    ):
+        """Initializes a PromiseTensor
+
+        Args:
+            shape: the shape that should have the tensors keeping the promise.
+            owner: an optional BaseWorker object to specify the worker on which
+                the tensor is located.
+            id: an optional string or integer id of the PromiseTensor.
+            tensor_type: the type that should have the tensors keeping the promise.
+            plans: the ids of the plans waiting for the promise to be kept. When the promise is
+                kept, all the plans corresponding to these ids will be executed if the other
+                promises they were waiting for are also kept.
+            tags: an optional set of hashtags corresponding to this tensor
+                which this tensor should be searchable for.
+            description: an optional string describing the purpose of the
+                tensor.
+        """
+
+        if owner is None:
+            owner = sy.local_worker
+
+        # constructors for AbstractTensor and Promise
+        AbstractTensor.__init__(self, id=id, owner=owner, tags=tags, description=description)
+        Promise.__init__(self, owner=owner, obj_type=tensor_type, plans=plans)
+
+        self._shape = shape
+
+        del self.child
+
+    def torch_type(self):
+        return self.obj_type
+
+    @property
+    def shape(self):
+        return self._shape
+
+    @property
+    def grad(self):
+        return None
+        # if not hasattr(self, "_grad"):
+        #     self._grad = PromiseTensor(shape=self._shape, tensor_type=self.torch_type()).wrap()
+        #
+        # return self._grad
+
+    def __str__(self):
+        return f"[PromiseTensor({self.owner.id}:{self.id}) -future-> {self.obj_type.split('.')[-1]} -blocking-> {len(self.plans)} plans]"
+
+    def __repr__(self):
+        return self.__str__()
+
+    @staticmethod
+    def simplify(worker: AbstractWorker, tensor: "PromiseTensor") -> tuple:
+        """Takes the attributes of a FixedPrecisionTensor and saves them in a tuple.
+
+        Args:
+            tensor: a FixedPrecisionTensor.
+
+        Returns:
+            tuple: a tuple holding the unique attributes of the fixed precision tensor.
+        """
+
+        return (
+            sy.serde._simplify(worker, tensor.id),
+            sy.serde._simplify(worker, tensor.shape),
+            sy.serde._simplify(worker, tensor.obj_type),
+            sy.serde._simplify(worker, tensor.plans),
+        )
+
+    @staticmethod
+    def detail(worker: AbstractWorker, tensor_tuple: tuple) -> "PromiseTensor":
+        """
+            This function reconstructs a FixedPrecisionTensor given it's attributes in form of a tuple.
+            Args:
+                worker: the worker doing the deserialization
+                tensor_tuple: a tuple holding the attributes of the FixedPrecisionTensor
+            Returns:
+                FixedPrecisionTensor: a FixedPrecisionTensor
+            Examples:
+                shared_tensor = detail(data)
+            """
+
+        id, shape, tensor_type, plans = tensor_tuple
+
+        id = sy.serde._detail(worker, id)
+        shape = sy.serde._detail(worker, shape)
+        tensor_type = sy.serde._detail(worker, tensor_type)
+        plans = sy.serde._detail(worker, plans)
+
+        tensor = PromiseTensor(
+            owner=worker, id=id, shape=shape, tensor_type=tensor_type, plans=plans
+        )
+
+        return tensor
+
+
+### Register the tensor with hook_args.py ###
+hook_args.default_register_tensor(PromiseTensor)

syft/generic/object_storage.py

@@ -15,6 +15,7 @@ class ObjectStorage:
     """
 
     def __init__(self):
+        # This is the collection of objects being stored.
         self._objects = {}
 
     def register_obj(self, obj: object, obj_id: Union[str, int] = None):
@@ -103,7 +104,7 @@ def force_rm_obj(self, remote_key: Union[str, int]):
         """
         if remote_key in self._objects:
             obj = self._objects[remote_key]
-            if hasattr(obj, "child") and obj.child is not None:
+            if hasattr(obj, "child") and hasattr(obj.child, "garbage_collect_data"):
                 obj.child.garbage_collect_data = True
             del self._objects[remote_key]
 

syft/generic/pointers/pointer_tensor.py

@@ -265,6 +265,22 @@ def move(self, location):
         ptr.garbage_collect_data = False
         return ptr
 
+    def remote_send(self, destination, change_location=False):
+        """ Request the worker where the tensor being pointed to belongs to send it to destination.
+        For instance, if C holds a pointer, ptr, to a tensor on A and calls ptr.remote_send(B),
+        C will hold a pointer to a pointer on A which points to the tensor on B.
+        If change_location is set to True, the original pointer will point to the moved object.
+        Considering the same example as before with ptr.remote_send(B, change_location=True):
+        C will hold a pointer to the tensor on B. We may need to be careful here because this pointer 
+        will have 2 references pointing to it.
+        """
+        args = (destination,)
+        kwargs = {"inplace": True}
+        self.owner.send_command(message=("send", self, args, kwargs), recipient=self.location)
+        if change_location:
+            self.location = destination
+        return self
+
     def remote_get(self):
         self.owner.send_command(message=("mid_get", self, (), {}), recipient=self.location)
         return self
@@ -369,6 +385,34 @@ def share(self, *args, **kwargs):
 
         return response
 
+    def keep(self, *args, **kwargs):
+        """
+        Send a command to remote worker to keep a promise
+
+        Returns:
+            A pointer to a Tensor
+        """
+
+        # Send the command
+        command = ("keep", self, args, kwargs)
+
+        response = self.owner.send_command(self.location, command)
+
+        return response
+
+    def value(self, *args, **kwargs):
+        """
+        Send a command to remote worker to get the result generated by a promise.
+
+        Returns:
+            A pointer to a Tensor
+        """
+        command = ("value", self, args, kwargs)
+
+        response = self.owner.send_command(self.location, command)
+
+        return response
+
     def share_(self, *args, **kwargs):
         """
         Send a command to remote worker to additively share inplace a tensor

syft/messaging/__init__.py

@@ -0,0 +1 @@
+