| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| """Miscellaneous utilities.""" |
|
|
| import dataclasses |
| import re |
| from typing import Any, Callable, Iterable, Optional, TypeVar, Union |
|
|
| import numpy as np |
| import torch as t |
|
|
| InputTensor = Union[t.Tensor, np.ndarray, int, float, Iterable] |
| TorchDevice = Union[t.device, str, None] |
| T = TypeVar("T") |
|
|
|
|
| class TensorContainerMixin: |
| """Allows unified operation on all tensors contained in a dataclass.""" |
|
|
| def _apply(self, fn: Callable[[t.Tensor], t.Tensor]): |
| result = [] |
| for field in dataclasses.fields(self): |
| field = getattr(self, field.name) |
| if t.is_tensor(field): |
| field = fn(field) |
| elif isinstance(field, list) or isinstance(field, tuple): |
| field = [fn(e) if t.is_tensor(e) else e for e in field] |
| elif isinstance(field, TensorContainerMixin): |
| field = field._apply(fn) |
| result.append(field) |
| return type(self)(*result) |
|
|
| def cuda(self: T) -> T: |
| return self._apply(lambda v: v.cuda()) |
|
|
| def cpu(self: T) -> T: |
| return self._apply(lambda v: v.cpu()) |
|
|
| def detach(self: T) -> T: |
| return self._apply(lambda v: v.detach()) |
|
|
| def numpy(self: T) -> T: |
| return self._apply(lambda v: v.numpy()) |
|
|
| def to(self: T, device: TorchDevice) -> T: |
| return self._apply(lambda v: v.to(device)) |
|
|
| def __getitem__(self: T, index: Any) -> T: |
| return self._apply(lambda v: v[index]) |
|
|
| def get_structure(self) -> dict[str, str]: |
| """Debugging routine, returns type and shape of the each field.""" |
| result = {} |
| for field in dataclasses.fields(self): |
| v = getattr(self, field.name) |
| if t.is_tensor(v): |
| v: t.Tensor = v.detach() |
| dtype = re.sub(r"^torch\.", "", str(v.dtype)) |
| structure = f"t.{dtype}{list(v.shape)}({v.device})" |
| elif isinstance(v, np.ndarray): |
| structure = f"np.{v.dtype.name}{list(v.shape)}" |
| elif isinstance(v, list): |
| structure = f"list[{len(v)}]" |
| elif isinstance(v, tuple): |
| structure = f"tuple[{len(v)}]" |
| else: |
| structure = f"{type(v).__name__}" |
| result[field.name] = structure |
| return result |
|
|
|
|
| def to_tensor(v: InputTensor, dtype: t.dtype, |
| device: Optional[Union[t.device, str]] = None) -> t.Tensor: |
| """Converts a value to tensor, checking the type. |
| |
| Args: |
| v: The value to convert. If it is already a tensor or an array, this |
| function checks that the type is equal to dtype. Otherwise, uses |
| torch.as_tensor to convert it to tensor. |
| dtype: The required type. |
| device: The target tensor device (optional(. |
| |
| Returns: |
| The resulting tensor |
| |
| """ |
| if not t.is_tensor(v): |
| if hasattr(v, "__array_interface__"): |
| |
| v = t.as_tensor(v) |
| else: |
| v = t.as_tensor(v, dtype=dtype) |
|
|
| if v.dtype != dtype: |
| raise ValueError(f"Expecting type '{dtype}', found '{v.dtype}'") |
|
|
| if device is not None: |
| v = v.to(device) |
|
|
| return v |
|
|
