Revert "TensorBearer API and cleaner integrator steps (#107)"

This reverts commit dcff6d6.

Author: bqth29

src/simulated_bifurcation/core/ising.py

@@ -24,13 +24,13 @@
 from numpy import ndarray
 
 from ..optimizer import SimulatedBifurcationEngine, SimulatedBifurcationOptimizer
-from .tensor_bearer import TensorBearer
+from .utils import safe_get_device, safe_get_dtype
 
 # Workaround because `Self` type is only available in Python >= 3.11
 SelfIsing = TypeVar("SelfIsing", bound="Ising")
 
 
-class Ising(TensorBearer):
+class Ising(object):
     """
     Internal implementation of the Ising model.
 
@@ -92,10 +92,13 @@ def __init__(
         dtype: Optional[torch.dtype] = None,
         device: Optional[Union[str, torch.device]] = None,
     ) -> None:
-        super().__init__(dtype=dtype, device=device)
-        J = self._safe_get_tensor(J)
-        if h is not None:
-            h = self._safe_get_tensor(h)
+        self._dtype = safe_get_dtype(dtype)
+        self._device = safe_get_device(device)
+
+        if isinstance(J, ndarray):
+            J = torch.from_numpy(J)
+        if isinstance(h, ndarray):
+            h = torch.from_numpy(h)
 
         if J.ndim != 2:
             raise ValueError(
@@ -107,25 +110,27 @@ def __init__(
                 f"Expected J to be square, but got {rows} rows and {cols} columns."
             )
 
-        self._J = J
+        self._J = J.to(dtype=self._dtype, device=self._device)
         self._dimension = rows
 
         if h is None:
-            self._h = torch.zeros(self._dimension, dtype=self.dtype, device=self.device)
+            self._h = torch.zeros(
+                self._dimension, dtype=self._dtype, device=self._device
+            )
         elif h.shape != (self._dimension,):
             raise ValueError(
                 f"Expected the shape of h to be {self._dimension}, but got {tuple(h.shape)}."
             )
         else:
-            self._h = h
+            self._h = h.to(dtype=self._dtype, device=self._device)
 
         self._has_linear_term = not torch.equal(
             self._h,
-            torch.zeros(self._dimension, dtype=self.dtype, device=self.device),
+            torch.zeros(self._dimension, dtype=self._dtype, device=self._device),
         )
 
     def __neg__(self) -> SelfIsing:
-        return self.__class__(-self._J, -self._h, self.dtype, self.device)
+        return self.__class__(-self._J, -self._h, self._dtype, self._device)
 
     def as_simulated_bifurcation_tensor(self) -> torch.Tensor:
         """
@@ -174,8 +179,8 @@ def as_simulated_bifurcation_tensor(self) -> torch.Tensor:
         if self._has_linear_term:
             sb_tensor = torch.zeros(
                 (self._dimension + 1, self._dimension + 1),
-                dtype=self.dtype,
-                device=self.device,
+                dtype=self._dtype,
+                device=self._device,
             )
             sb_tensor[: self._dimension, : self._dimension] = symmetrical_J
             sb_tensor[: self._dimension, self._dimension] = -self._h
@@ -346,8 +351,6 @@ def minimize(
             verbose,
             sampling_period,
             convergence_threshold,
-            self.dtype,
-            self.device,
         )
         tensor = self.as_simulated_bifurcation_tensor()
         spins = optimizer.run_integrator(tensor, early_stopping)

src/simulated_bifurcation/core/quadratic_polynomial.py

@@ -28,11 +28,20 @@
 from sympy import Poly
 
 from .ising import Ising
-from .tensor_bearer import TensorBearer
+from .utils import safe_get_device, safe_get_dtype
 from .variable import Variable
 
+INTEGER_REGEX = re.compile("^int[1-9][0-9]*$")
+DOMAIN_ERROR = ValueError(
+    f'Input type must be one of "spin" or "binary", or be a string starting'
+    f'with "int" and be followed by a positive integer.\n'
+    f"More formally, it should match the following regular expression.\n"
+    f"{INTEGER_REGEX}\n"
+    f'Examples: "int7", "int42", ...'
+)
 
-class QuadraticPolynomial(TensorBearer):
+
+class QuadraticPolynomial(object):
     """
     Internal implementation of a multivariate quadratic polynomial.
 
@@ -125,7 +134,7 @@ class QuadraticPolynomial(TensorBearer):
     Maximize this polynomial over {0, 1, ..., 14, 15} x {0, 1, ..., 14, 15}
     (outputs are located on the GPU)
 
-      >>> best_vector, best_value = poly.maximize(domain="int4")
+      >>> best_vector, best_value = poly.maximize(domain="int4)
       >>> best_vector
       tensor([ 0., 15.], device='cuda:0')
       >>> best_value
@@ -148,7 +157,8 @@ def __init__(
         dtype: Optional[torch.dtype] = None,
         device: Optional[Union[str, torch.device]] = None,
     ):
-        super().__init__(dtype=dtype, device=device)
+        self._dtype = safe_get_dtype(dtype)
+        self._device = safe_get_device(device)
         self.sb_result = None
 
         if len(polynomial_data) == 1 and isinstance(polynomial_data[0], Poly):
@@ -159,17 +169,17 @@ def __init__(
                 )
             dimension = len(polynomial.gens)
             self._quadratic_coefficients = torch.zeros(
-                dimension, dimension, dtype=self.dtype, device=self.device
+                dimension, dimension, dtype=self._dtype, device=self._device
             )
             self._linear_coefficients = torch.zeros(
-                dimension, dtype=self.dtype, device=self.device
+                dimension, dtype=self._dtype, device=self._device
             )
-            self._bias = torch.tensor(0.0, dtype=self.dtype, device=self.device)
+            self._bias = torch.tensor(0.0, dtype=self._dtype, device=self._device)
             for monom, coeff in polynomial.terms():
                 coeff = float(coeff)
                 if sum(monom) == 0:
                     self._bias = torch.tensor(
-                        coeff, dtype=self.dtype, device=self.device
+                        coeff, dtype=self._dtype, device=self._device
                     )
                 elif sum(monom) == 1:
                     self._linear_coefficients[monom.index(1)] = coeff
@@ -186,58 +196,67 @@ def __init__(
             self._quadratic_coefficients = None
             self._linear_coefficients = None
             self._bias = None
-            for polynomial_data_element in polynomial_data:
-                # noinspection PyTypeChecker
-                tensor_like = self._safe_get_tensor(polynomial_data_element)
-                if tensor_like.ndim == 0:
-                    attribute_to_set = "_bias"
-                elif tensor_like.ndim == 1:
-                    attribute_to_set = "_linear_coefficients"
-                elif tensor_like.ndim == 2:
-                    attribute_to_set = "_quadratic_coefficients"
-                    rows, cols = tensor_like.shape
-                    if rows != cols:
+            for tensor_like in polynomial_data:
+                if isinstance(tensor_like, np.ndarray):
+                    tensor_like = torch.from_numpy(tensor_like)
+                elif isinstance(tensor_like, (int, float)):
+                    tensor_like = torch.tensor(
+                        tensor_like, dtype=self._dtype, device=self._device
+                    )
+                if isinstance(tensor_like, torch.Tensor):
+                    if tensor_like.ndim == 0:
+                        attribute_to_set = "_bias"
+                    elif tensor_like.ndim == 1:
+                        attribute_to_set = "_linear_coefficients"
+                    elif tensor_like.ndim == 2:
+                        attribute_to_set = "_quadratic_coefficients"
+                        rows, cols = tensor_like.shape
+                        if rows != cols:
+                            raise ValueError(
+                                "Provided quadratic coefficients tensor is not square."
+                            )
+                    else:
                         raise ValueError(
-                            "Provided quadratic coefficients tensor is not square."
+                            f"Expected a tensor with at most 2 dimensions, got {tensor_like.ndim}."
+                        )
+                    if getattr(self, attribute_to_set) is not None:
+                        raise ValueError(
+                            f"Providing two tensors for the same degree is ambiguous. Got at least two tensors for degree {tensor_like.ndim}."
+                        )
+                    else:
+                        if tensor_like.ndim > 0:
+                            if dimension is None:
+                                dimension = tensor_like.shape[0]
+                            elif dimension != tensor_like.shape[0]:
+                                raise ValueError(
+                                    f"Inconsistant shape among provided tensors. Expected {dimension} but got {tensor_like.shape[0]}."
+                                )
+                        setattr(
+                            self,
+                            attribute_to_set,
+                            tensor_like.to(dtype=self._dtype, device=self._device),
                         )
                 else:
                     raise ValueError(
-                        f"Expected a tensor with at most 2 dimensions, got {tensor_like.ndim}."
-                    )
-                if getattr(self, attribute_to_set) is not None:
-                    raise ValueError(
-                        f"Providing two tensors for the same degree is ambiguous. Got at least two tensors for degree {tensor_like.ndim}."
-                    )
-                else:
-                    if tensor_like.ndim > 0:
-                        if dimension is None:
-                            dimension = tensor_like.shape[0]
-                        elif dimension != tensor_like.shape[0]:
-                            raise ValueError(
-                                f"Inconsistent shape among provided tensors. Expected {dimension} but got {tensor_like.shape[0]}."
-                            )
-                    setattr(
-                        self,
-                        attribute_to_set,
-                        tensor_like,
+                        f"Unsupported coefficient tensor type: {type(tensor_like)}. Expected a torch.Tensor or a numpy.ndarray."
                     )
             if self._quadratic_coefficients is None:
                 self._quadratic_coefficients = torch.zeros(
-                    dimension, dimension, dtype=self.dtype, device=self.device
+                    dimension, dimension, dtype=self._dtype, device=self._device
                 )
             if self._linear_coefficients is None:
                 self._linear_coefficients = torch.zeros(
-                    dimension, dtype=self.dtype, device=self.device
+                    dimension, dtype=self._dtype, device=self._device
                 )
             if self._bias is None:
-                self._bias = torch.tensor(0.0, dtype=self.dtype, device=self.device)
+                self._bias = torch.tensor(0.0, dtype=self._dtype, device=self._device)
 
         self._dimension = self._quadratic_coefficients.shape[0]
 
     def __call__(self, value: Union[torch.Tensor, np.ndarray]) -> torch.Tensor:
         if not isinstance(value, torch.Tensor):
             try:
-                value = torch.tensor(value, dtype=self.dtype, device=self.device)
+                value = torch.tensor(value, dtype=self._dtype, device=self._device)
             except Exception as err:
                 raise TypeError("Input value cannot be cast to Tensor.") from err
 
@@ -349,12 +368,12 @@ def to_ising(self, domain: Union[str, List[str]]) -> Ising:
         """
         variables = self.__get_variables(domain=domain)
         spin_identity_vector = QuadraticPolynomial.__spin_identity_vector(
-            variables=variables, dtype=self.dtype, device=self.device
+            variables=variables, dtype=self._dtype, device=self._device
         )
         spin_weighted_integer_to_binary_matrix = (
             spin_identity_vector + 1
         ) * QuadraticPolynomial.__integer_to_binary_matrix(
-            variables=variables, dtype=self.dtype, device=self.device
+            variables=variables, dtype=self._dtype, device=self._device
         )
         symmetric_quadratic_tensor = (
             self._quadratic_coefficients + self._quadratic_coefficients.t()
@@ -377,7 +396,7 @@ def to_ising(self, domain: Union[str, List[str]]) -> Ising:
             -1,
         )
         torch.diag(J)[...] = 0
-        return Ising(J, h, self.dtype, self.device)
+        return Ising(J, h, self._dtype, self._device)
 
     def convert_spins(
         self, optimized_spins: torch.Tensor, domain: Union[str, List[str]]
@@ -422,12 +441,12 @@ def convert_spins(
         """
         variables = self.__get_variables(domain=domain)
         spin_identity_vector = QuadraticPolynomial.__spin_identity_vector(
-            variables=variables, dtype=self.dtype, device=self.device
+            variables=variables, dtype=self._dtype, device=self._device
         )
         spin_weighted_integer_to_binary_matrix = (
             spin_identity_vector + 1
         ) * QuadraticPolynomial.__integer_to_binary_matrix(
-            variables=variables, dtype=self.dtype, device=self.device
+            variables=variables, dtype=self._dtype, device=self._device
         )
         return (
             None
@@ -562,8 +581,9 @@ def __optimize(
             convergence_threshold=convergence_threshold,
             timeout=timeout,
         )
-        self.sb_result = self._cast_tensor(self.convert_spins(optimized_spins, domain))
-
+        self.sb_result = self.convert_spins(optimized_spins, domain).to(
+            dtype=self._dtype, device=self._device
+        )
         result = self.sb_result.t()
         evaluation = self(result)
         if best_only:

src/simulated_bifurcation/core/tensor_bearer.py

@@ -0,0 +1,17 @@
+from typing import Optional, Union
+
+import torch
+
+
+def safe_get_dtype(dtype: Optional[torch.dtype]) -> torch.dtype:
+    if dtype is None:
+        return torch.float32
+    elif dtype == torch.float32 or dtype == torch.float64:
+        return dtype
+    raise ValueError(
+        "The Simulated Bifurcation algorithm can only run with a torch.float32 or a torch.float64 dtype."
+    )
+
+
+def safe_get_device(device: Optional[Union[str, torch.device]]) -> torch.device:
+    return torch.get_default_device() if device is None else torch.device(device)