| from dataclasses import dataclass |
| from typing import Literal |
| import numpy as np |
|
|
| Backend = Literal["numpy", "jax", "torch"] |
|
|
| @dataclass |
| class BackendOps: |
| backend: Backend |
| xp: object |
|
|
| def asarray(self, x, atleast_2d: bool = False): |
| if self.backend == "torch": |
| if isinstance(x, self.xp.Tensor): |
| arr = x.to(dtype=self.xp.float64) |
| else: |
| arr = self.xp.as_tensor(x, dtype=self.xp.float64) |
| if atleast_2d and arr.ndim < 2: |
| if arr.ndim == 1: |
| arr = arr.unsqueeze(0) |
| else: |
| arr = arr.reshape(1, 1) |
| return arr |
|
|
| arr = self.xp.asarray(x, dtype=self.xp.float64) |
| if atleast_2d: |
| arr = self.xp.atleast_2d(arr) |
| return arr |
|
|
| def maximum(self, x, y): |
| return self.xp.maximum(x, y) |
|
|
| def minimum(self, x, y): |
| return self.xp.minimum(x, y) |
|
|
| def clamp(self, x, min=None, max=None): |
| if self.backend == "torch": |
| return self.xp.clamp(x, min=min, max=max) |
| if min is not None: |
| x = self.xp.maximum(x, min) |
| if max is not None: |
| x = self.xp.minimum(x, max) |
| return x |
|
|
| def clamp_min(self, x, min_value): |
| return self.maximum(x, min_value) |
|
|
| def clamp_max(self, x, max_value): |
| return self.minimum(x, max_value) |
|
|
| def exp(self, x): |
| return self.xp.exp(x) |
|
|
| def stack(self, arrays, axis=-1): |
| if self.backend == "torch": |
| return self.xp.stack(arrays, dim=axis) |
| return self.xp.stack(arrays, axis=axis) |
|
|
| def get_ops(backend: Backend) -> BackendOps: |
| if backend == "numpy": |
| xp = np |
| elif backend == "jax": |
| import jax.numpy as jnp |
| xp = jnp |
| elif backend == "torch": |
| import torch |
| xp = torch |
| else: |
| raise ValueError(f"Unsupported backend: {backend}") |
|
|
| return BackendOps(backend=backend, xp=xp) |
