vectorphile 0.1.0__py3-none-any.whl

vectorphile/optim/adam.py

@@ -0,0 +1,71 @@
+"""Adam and AdamW optimizers."""
+import numpy as np
+from vectorphile.optim.optimizer import Optimizer
+
+
+class Adam(Optimizer):
+    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0.0, amsgrad=False):
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay, amsgrad=amsgrad)
+        super().__init__(params, defaults)
+        self.state = {}
+
+    def step(self):
+        for group in self.param_groups:
+            lr = group['lr']
+            b1, b2 = group['betas']
+            eps = group['eps']
+            wd = group['weight_decay']
+            amsgrad = group['amsgrad']
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                g = p.grad._data
+                pid = id(p)
+                if pid not in self.state:
+                    self.state[pid] = {'step': 0, 'm': np.zeros_like(p._data), 'v': np.zeros_like(p._data)}
+                    if amsgrad:
+                        self.state[pid]['v_max'] = np.zeros_like(p._data)
+                s = self.state[pid]
+                s['step'] += 1
+                s['m'] = b1 * s['m'] + (1 - b1) * g
+                s['v'] = b2 * s['v'] + (1 - b2) * g**2
+                m_hat = s['m'] / (1 - b1**s['step'])
+                v_hat = s['v'] / (1 - b2**s['step'])
+                if amsgrad:
+                    s['v_max'] = np.maximum(s['v_max'], v_hat)
+                    denom = np.sqrt(s['v_max']) + eps
+                else:
+                    denom = np.sqrt(v_hat) + eps
+                if wd != 0:
+                    p._data -= lr * wd * p._data
+                p._data -= lr * m_hat / denom
+
+
+class AdamW(Optimizer):
+    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0.01):
+        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
+        super().__init__(params, defaults)
+        self.state = {}
+
+    def step(self):
+        for group in self.param_groups:
+            lr = group['lr']
+            b1, b2 = group['betas']
+            eps = group['eps']
+            wd = group['weight_decay']
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                # Decoupled weight decay
+                p._data *= (1 - lr * wd)
+                g = p.grad._data
+                pid = id(p)
+                if pid not in self.state:
+                    self.state[pid] = {'step': 0, 'm': np.zeros_like(p._data), 'v': np.zeros_like(p._data)}
+                s = self.state[pid]
+                s['step'] += 1
+                s['m'] = b1 * s['m'] + (1 - b1) * g
+                s['v'] = b2 * s['v'] + (1 - b2) * g**2
+                m_hat = s['m'] / (1 - b1**s['step'])
+                v_hat = s['v'] / (1 - b2**s['step'])
+                p._data -= lr * m_hat / (np.sqrt(v_hat) + eps)

vectorphile/optim/lr_scheduler.py

@@ -0,0 +1,110 @@
+"""Learning rate schedulers."""
+import math
+
+
+class _LRScheduler:
+    def __init__(self, optimizer, last_epoch=-1):
+        self.optimizer = optimizer
+        self.last_epoch = last_epoch
+        self.base_lrs = [g['lr'] for g in optimizer.param_groups]
+        self.step()
+
+    def get_lr(self):
+        raise NotImplementedError
+
+    def step(self, epoch=None):
+        if epoch is None:
+            self.last_epoch += 1
+        else:
+            self.last_epoch = epoch
+        lrs = self.get_lr()
+        for g, lr in zip(self.optimizer.param_groups, lrs):
+            g['lr'] = lr
+
+
+class StepLR(_LRScheduler):
+    def __init__(self, optimizer, step_size, gamma=0.1, last_epoch=-1):
+        self.step_size = step_size
+        self.gamma = gamma
+        super().__init__(optimizer, last_epoch)
+
+    def get_lr(self):
+        return [base * self.gamma ** (self.last_epoch // self.step_size) for base in self.base_lrs]
+
+
+class ExponentialLR(_LRScheduler):
+    def __init__(self, optimizer, gamma, last_epoch=-1):
+        self.gamma = gamma
+        super().__init__(optimizer, last_epoch)
+
+    def get_lr(self):
+        return [base * self.gamma ** self.last_epoch for base in self.base_lrs]
+
+
+class CosineAnnealingLR(_LRScheduler):
+    def __init__(self, optimizer, T_max, eta_min=0.0, last_epoch=-1):
+        self.T_max = T_max
+        self.eta_min = eta_min
+        super().__init__(optimizer, last_epoch)
+
+    def get_lr(self):
+        t = self.last_epoch
+        return [
+            self.eta_min + (base - self.eta_min) * (1 + math.cos(math.pi * t / self.T_max)) / 2
+            for base in self.base_lrs
+        ]
+
+
+class LinearLR(_LRScheduler):
+    def __init__(self, optimizer, start_factor=1.0/3, end_factor=1.0, total_iters=5, last_epoch=-1):
+        self.start_factor = start_factor
+        self.end_factor = end_factor
+        self.total_iters = total_iters
+        super().__init__(optimizer, last_epoch)
+
+    def get_lr(self):
+        t = min(self.last_epoch, self.total_iters)
+        alpha = t / self.total_iters
+        factor = self.start_factor + alpha * (self.end_factor - self.start_factor)
+        return [base * factor for base in self.base_lrs]
+
+
+class ReduceLROnPlateau:
+    def __init__(self, optimizer, mode='min', factor=0.1, patience=10, threshold=1e-4,
+                 threshold_mode='rel', cooldown=0, min_lr=0.0, eps=1e-8):
+        self.optimizer = optimizer
+        self.mode = mode
+        self.factor = factor
+        self.patience = patience
+        self.threshold = threshold
+        self.threshold_mode = threshold_mode
+        self.cooldown = cooldown
+        self.min_lr = min_lr
+        self.eps = eps
+        self.best = None
+        self.num_bad_epochs = 0
+        self.cooldown_counter = 0
+
+    def step(self, metrics):
+        current = float(metrics)
+        if self.best is None:
+            self.best = current
+            return
+        if self.mode == 'min':
+            improved = current < self.best - self.threshold
+        else:
+            improved = current > self.best + self.threshold
+        if improved:
+            self.best = current
+            self.num_bad_epochs = 0
+        else:
+            self.num_bad_epochs += 1
+        if self.cooldown_counter > 0:
+            self.cooldown_counter -= 1
+            return
+        if self.num_bad_epochs >= self.patience:
+            for g in self.optimizer.param_groups:
+                new_lr = max(g['lr'] * self.factor, self.min_lr)
+                g['lr'] = new_lr
+            self.cooldown_counter = self.cooldown
+            self.num_bad_epochs = 0

vectorphile/optim/optimizer.py

@@ -0,0 +1,30 @@
+"""Base Optimizer class."""
+from typing import List, Dict, Any
+
+
+class Optimizer:
+    def __init__(self, params, defaults: Dict[str, Any]):
+        if isinstance(params, dict):
+            params = list(params.values())
+        self.param_groups: List[Dict] = []
+        self.defaults = defaults
+        self.add_param_group({'params': list(params)})
+
+    def add_param_group(self, param_group: Dict):
+        group = {**self.defaults, **param_group}
+        self.param_groups.append(group)
+
+    def zero_grad(self):
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is not None:
+                    p.grad = None
+
+    def step(self):
+        raise NotImplementedError
+
+    def state_dict(self) -> Dict:
+        return {'state': self.state, 'param_groups': self.param_groups}
+
+    def load_state_dict(self, state_dict: Dict):
+        self.state = state_dict['state']

vectorphile/optim/rmsprop.py

@@ -0,0 +1,34 @@
+"""RMSprop and Adagrad optimizers."""
+import numpy as np
+from vectorphile.optim.optimizer import Optimizer
+
+
+class RMSprop(Optimizer):
+    def __init__(self, params, lr=0.01, alpha=0.99, eps=1e-8, weight_decay=0.0, momentum=0.0):
+        defaults = dict(lr=lr, alpha=alpha, eps=eps, weight_decay=weight_decay, momentum=momentum)
+        super().__init__(params, defaults)
+        self.state = {}
+
+    def step(self):
+        for group in self.param_groups:
+            lr = group['lr']
+            alpha = group['alpha']
+            eps = group['eps']
+            wd = group['weight_decay']
+            mu = group['momentum']
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                g = p.grad._data.copy()
+                if wd != 0:
+                    g += wd * p._data
+                pid = id(p)
+                if pid not in self.state:
+                    self.state[pid] = {'sq': np.zeros_like(p._data), 'buf': np.zeros_like(p._data)}
+                s = self.state[pid]
+                s['sq'] = alpha * s['sq'] + (1 - alpha) * g**2
+                step = g / (np.sqrt(s['sq']) + eps)
+                if mu != 0:
+                    s['buf'] = mu * s['buf'] + step
+                    step = s['buf']
+                p._data -= lr * step

vectorphile/optim/sgd.py

@@ -0,0 +1,38 @@
+"""SGD optimizer with momentum and weight decay."""
+import numpy as np
+from vectorphile.optim.optimizer import Optimizer
+from vectorphile.core.tensor import Tensor
+
+
+class SGD(Optimizer):
+    def __init__(self, params, lr=0.01, momentum=0.0, weight_decay=0.0, nesterov=False, dampening=0.0):
+        defaults = dict(lr=lr, momentum=momentum, weight_decay=weight_decay,
+                        nesterov=nesterov, dampening=dampening)
+        super().__init__(params, defaults)
+        self.state = {}
+
+    def step(self):
+        for group in self.param_groups:
+            lr = group['lr']
+            momentum = group['momentum']
+            weight_decay = group['weight_decay']
+            dampening = group['dampening']
+            nesterov = group['nesterov']
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                g = p.grad._data.copy()
+                if weight_decay != 0:
+                    g += weight_decay * p._data
+                pid = id(p)
+                if momentum != 0:
+                    if pid not in self.state:
+                        self.state[pid] = {'momentum_buffer': np.zeros_like(p._data)}
+                    buf = self.state[pid]['momentum_buffer']
+                    buf *= momentum
+                    buf += (1 - dampening) * g
+                    if nesterov:
+                        g = g + momentum * buf
+                    else:
+                        g = buf
+                p._data -= lr * g

vectorphile/optimize/__init__.py

@@ -0,0 +1,97 @@
+"""Numerical optimization routines."""
+import numpy as np
+from typing import Callable, Optional, Tuple
+from vectorphile.core.tensor import Tensor
+
+
+def minimize(fun: Callable, x0, method='bfgs', jac=None, tol=1e-6, options=None):
+    """Minimize a scalar function. Wraps scipy.optimize.minimize when available."""
+    try:
+        from scipy.optimize import minimize as sp_minimize
+        x0_arr = x0._data.flatten() if isinstance(x0, Tensor) else np.array(x0).flatten()
+        def fn(x):
+            t = Tensor(x.reshape(x0_arr.shape) if isinstance(x0, Tensor) else x, requires_grad=True)
+            result = fun(t)
+            return float(result._data) if isinstance(result, Tensor) else float(result)
+        result = sp_minimize(fn, x0_arr, method=method.upper(), jac=jac, tol=tol, options=options)
+        result.x = Tensor(result.x.reshape(x0._data.shape if isinstance(x0, Tensor) else x0.shape))
+        return result
+    except ImportError:
+        return _gradient_descent(fun, x0, tol=tol, options=options or {})
+
+
+def _gradient_descent(fun: Callable, x0, lr=0.01, tol=1e-6, max_iter=1000, options=None):
+    if options:
+        lr = options.get('lr', lr)
+        max_iter = options.get('maxiter', max_iter)
+    if isinstance(x0, Tensor):
+        x = Tensor(x0._data.copy(), requires_grad=True)
+    else:
+        x = Tensor(np.array(x0, dtype=float), requires_grad=True)
+    for i in range(max_iter):
+        if x.grad is not None:
+            x.grad = None
+        result = fun(x)
+        result.backward()
+        if x.grad is None:
+            break
+        grad_norm = float(np.linalg.norm(x.grad._data))
+        if grad_norm < tol:
+            break
+        x._data -= lr * x.grad._data
+
+    class Result:
+        pass
+    r = Result()
+    r.x = x
+    r.fun = float(fun(x)._data)
+    r.success = True
+    return r
+
+
+def root(fun: Callable, x0, method='hybr', tol=1e-6):
+    """Find root of a function."""
+    try:
+        from scipy.optimize import root as sp_root
+        x0_arr = x0._data.flatten() if isinstance(x0, Tensor) else np.array(x0).flatten()
+        def fn(x):
+            t = Tensor(x)
+            result = fun(t)
+            return result._data.flatten() if isinstance(result, Tensor) else np.array(result).flatten()
+        return sp_root(fn, x0_arr, method=method, tol=tol)
+    except ImportError:
+        raise ImportError("root requires scipy: pip install scipy")
+
+
+def linprog(c, A_ub=None, b_ub=None, A_eq=None, b_eq=None, bounds=None, method='highs'):
+    """Linear programming."""
+    try:
+        from scipy.optimize import linprog as sp_linprog
+        c_arr = c._data if isinstance(c, Tensor) else np.array(c)
+        return sp_linprog(c_arr, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq, bounds=bounds, method=method)
+    except ImportError:
+        raise ImportError("linprog requires scipy: pip install scipy")
+
+
+def curve_fit(f: Callable, xdata, ydata, p0=None):
+    """Curve fitting."""
+    try:
+        from scipy.optimize import curve_fit as sp_curve_fit
+        xd = xdata._data if isinstance(xdata, Tensor) else np.array(xdata)
+        yd = ydata._data if isinstance(ydata, Tensor) else np.array(ydata)
+        popt, pcov = sp_curve_fit(f, xd, yd, p0=p0)
+        return Tensor(popt.astype(np.float32)), Tensor(pcov.astype(np.float32))
+    except ImportError:
+        raise ImportError("curve_fit requires scipy: pip install scipy")
+
+
+def differential_evolution(fun: Callable, bounds, maxiter=1000, tol=0.01, seed=None):
+    """Global optimization via differential evolution."""
+    try:
+        from scipy.optimize import differential_evolution as sp_de
+        def fn(x):
+            result = fun(Tensor(x))
+            return float(result._data) if isinstance(result, Tensor) else float(result)
+        return sp_de(fn, bounds, maxiter=maxiter, tol=tol, seed=seed)
+    except ImportError:
+        raise ImportError("differential_evolution requires scipy: pip install scipy")

vectorphile/random/__init__.py

@@ -0,0 +1,64 @@
+"""Random number generation."""
+import numpy as np
+from vectorphile.core.tensor import Tensor
+
+
+def seed(s: int):
+    np.random.seed(s)
+
+def rand(*shape, device='cpu') -> Tensor:
+    if len(shape) == 1 and isinstance(shape[0], (tuple, list)):
+        shape = shape[0]
+    return Tensor(np.random.rand(*shape).astype(np.float32), device=device)
+
+def randn(*shape, device='cpu') -> Tensor:
+    if len(shape) == 1 and isinstance(shape[0], (tuple, list)):
+        shape = shape[0]
+    return Tensor(np.random.randn(*shape).astype(np.float32), device=device)
+
+def randint(low, high, shape, device='cpu') -> Tensor:
+    return Tensor(np.random.randint(low, high, shape).astype(np.int64), device=device)
+
+def choice(a, size=None, replace=True, p=None) -> Tensor:
+    if isinstance(a, Tensor):
+        a = a._data
+    return Tensor(np.random.choice(a, size=size, replace=replace, p=p))
+
+def shuffle(x: Tensor) -> Tensor:
+    data = x._data.copy()
+    np.random.shuffle(data)
+    return Tensor(data)
+
+def normal(loc=0.0, scale=1.0, size=None, device='cpu') -> Tensor:
+    return Tensor(np.random.normal(loc, scale, size).astype(np.float32), device=device)
+
+def uniform(low=0.0, high=1.0, size=None, device='cpu') -> Tensor:
+    return Tensor(np.random.uniform(low, high, size).astype(np.float32), device=device)
+
+def binomial(n, p, size=None) -> Tensor:
+    return Tensor(np.random.binomial(n, p, size).astype(np.float32))
+
+def poisson(lam=1.0, size=None) -> Tensor:
+    return Tensor(np.random.poisson(lam, size).astype(np.float32))
+
+def exponential(scale=1.0, size=None) -> Tensor:
+    return Tensor(np.random.exponential(scale, size).astype(np.float32))
+
+def multinomial(input: Tensor, num_samples: int, replacement=False) -> Tensor:
+    probs = input._data
+    probs = probs / probs.sum(axis=-1, keepdims=True)
+    if probs.ndim == 1:
+        return Tensor(np.random.choice(len(probs), size=num_samples, replace=replacement, p=probs).astype(np.int64))
+    result = np.stack([
+        np.random.choice(probs.shape[-1], size=num_samples, replace=replacement, p=row)
+        for row in probs.reshape(-1, probs.shape[-1])
+    ])
+    return Tensor(result.reshape(*probs.shape[:-1], num_samples).astype(np.int64))
+
+def permutation(x) -> Tensor:
+    if isinstance(x, int):
+        return Tensor(np.random.permutation(x).astype(np.int64))
+    return Tensor(np.random.permutation(x._data if isinstance(x, Tensor) else x))
+
+def bernoulli(p: Tensor) -> Tensor:
+    return Tensor((np.random.rand(*p._data.shape) < p._data).astype(np.float32))

vectorphile/signal/__init__.py

@@ -0,0 +1,67 @@
+"""Digital signal processing."""
+import numpy as np
+from vectorphile.core.tensor import Tensor
+
+
+def fft(x: Tensor) -> Tensor:
+    return Tensor(np.fft.fft(x._data))
+
+def ifft(x: Tensor) -> Tensor:
+    return Tensor(np.fft.ifft(x._data))
+
+def fftfreq(n: int, d: float = 1.0) -> Tensor:
+    return Tensor(np.fft.fftfreq(n, d).astype(np.float32))
+
+def convolve(x: Tensor, h: Tensor, mode='full') -> Tensor:
+    return Tensor(np.convolve(x._data.flatten(), h._data.flatten(), mode=mode).astype(np.float32))
+
+def correlate(x: Tensor, y: Tensor, mode='full') -> Tensor:
+    return Tensor(np.correlate(x._data.flatten(), y._data.flatten(), mode=mode).astype(np.float32))
+
+def stft(x: Tensor, n_fft=512, hop_length=None, win_length=None, window='hann') -> Tensor:
+    signal = x._data.flatten()
+    if hop_length is None:
+        hop_length = n_fft // 4
+    if win_length is None:
+        win_length = n_fft
+    if window == 'hann':
+        win = np.hanning(win_length)
+    else:
+        win = np.ones(win_length)
+    n = len(signal)
+    frames = []
+    for i in range(0, n - win_length + 1, hop_length):
+        frame = signal[i:i+win_length] * win
+        frames.append(np.fft.rfft(frame, n=n_fft))
+    return Tensor(np.array(frames))
+
+def spectrogram(x: Tensor, n_fft=512, hop_length=None, win_length=None) -> Tensor:
+    s = stft(x, n_fft, hop_length, win_length)
+    return Tensor(np.abs(s._data)**2)
+
+def butter(N: int, Wn, btype='low', output='ba'):
+    try:
+        from scipy.signal import butter as sp_butter
+        return sp_butter(N, Wn, btype=btype, output=output)
+    except ImportError:
+        raise ImportError("butter requires scipy: pip install scipy")
+
+def filtfilt(b, a, x: Tensor) -> Tensor:
+    try:
+        from scipy.signal import filtfilt as sp_filtfilt
+        return Tensor(sp_filtfilt(b, a, x._data).astype(np.float32))
+    except ImportError:
+        raise ImportError("filtfilt requires scipy: pip install scipy")
+
+def hilbert(x: Tensor) -> Tensor:
+    try:
+        from scipy.signal import hilbert as sp_hilbert
+        return Tensor(np.abs(sp_hilbert(x._data)).astype(np.float32))
+    except ImportError:
+        return x
+
+def resample(x: Tensor, num: int) -> Tensor:
+    signal = x._data.flatten()
+    n = len(signal)
+    indices = np.linspace(0, n - 1, num)
+    return Tensor(np.interp(indices, np.arange(n), signal).astype(np.float32))

vectorphile/sparse/__init__.py

@@ -0,0 +1,129 @@
+"""Sparse matrix support."""
+import numpy as np
+from vectorphile.core.tensor import Tensor
+
+
+class csr_matrix:
+    """Compressed Sparse Row matrix."""
+    def __init__(self, data, shape=None):
+        if isinstance(data, np.ndarray):
+            self._from_dense(data)
+        elif isinstance(data, Tensor):
+            self._from_dense(data._data)
+        elif isinstance(data, tuple) and len(data) == 3:
+            (vals, (row, col)), shape = data, shape
+            self.data = np.array(vals)
+            self.indices = np.array(col, dtype=int)
+            self.indptr = np.zeros(shape[0] + 1, dtype=int)
+            for r in row:
+                self.indptr[r + 1:] += 1
+            self.shape = shape
+        else:
+            raise ValueError("Unsupported input format")
+
+    def _from_dense(self, arr):
+        self.shape = arr.shape
+        rows, cols = np.nonzero(arr)
+        self.data = arr[rows, cols]
+        self.indices = cols
+        self.indptr = np.zeros(arr.shape[0] + 1, dtype=int)
+        for r in rows:
+            self.indptr[r + 1] += 1
+        self.indptr = np.cumsum(self.indptr)
+
+    def toarray(self) -> np.ndarray:
+        result = np.zeros(self.shape)
+        for i in range(self.shape[0]):
+            start, end = self.indptr[i], self.indptr[i+1]
+            result[i, self.indices[start:end]] = self.data[start:end]
+        return result
+
+    def to_tensor(self) -> Tensor:
+        return Tensor(self.toarray().astype(np.float32))
+
+    def __matmul__(self, other):
+        a = self.toarray()
+        if isinstance(other, csr_matrix):
+            return csr_matrix(a @ other.toarray())
+        if isinstance(other, np.ndarray):
+            return a @ other
+        if isinstance(other, Tensor):
+            return Tensor((a @ other._data).astype(np.float32))
+        return NotImplemented
+
+    @property
+    def nnz(self) -> int:
+        return len(self.data)
+
+    def __repr__(self):
+        return f'csr_matrix(shape={self.shape}, nnz={self.nnz})'
+
+
+class csc_matrix:
+    """Compressed Sparse Column matrix."""
+    def __init__(self, data):
+        if isinstance(data, np.ndarray):
+            arr = data
+        elif isinstance(data, Tensor):
+            arr = data._data
+        else:
+            arr = np.array(data)
+        self.shape = arr.shape
+        rows, cols = np.nonzero(arr)
+        order = np.argsort(cols)
+        self.data = arr[rows[order], cols[order]]
+        self.indices = rows[order]
+        self.indptr = np.zeros(arr.shape[1] + 1, dtype=int)
+        for c in cols[order]:
+            self.indptr[c + 1] += 1
+        self.indptr = np.cumsum(self.indptr)
+
+    def toarray(self) -> np.ndarray:
+        result = np.zeros(self.shape)
+        for j in range(self.shape[1]):
+            start, end = self.indptr[j], self.indptr[j+1]
+            result[self.indices[start:end], j] = self.data[start:end]
+        return result
+
+    def to_tensor(self) -> Tensor:
+        return Tensor(self.toarray().astype(np.float32))
+
+    @property
+    def nnz(self) -> int:
+        return len(self.data)
+
+
+class coo_matrix:
+    """Coordinate (COO) sparse matrix."""
+    def __init__(self, data):
+        if isinstance(data, tuple) and len(data) == 2:
+            (vals, (rows, cols)), shape = data
+            self.data = np.array(vals)
+            self.row = np.array(rows, dtype=int)
+            self.col = np.array(cols, dtype=int)
+            self.shape = shape
+        elif isinstance(data, np.ndarray):
+            arr = data
+            self.shape = arr.shape
+            self.row, self.col = np.nonzero(arr)
+            self.data = arr[self.row, self.col]
+        else:
+            arr = np.array(data)
+            self.shape = arr.shape
+            self.row, self.col = np.nonzero(arr)
+            self.data = arr[self.row, self.col]
+
+    def toarray(self) -> np.ndarray:
+        result = np.zeros(self.shape)
+        result[self.row, self.col] = self.data
+        return result
+
+    def tocsr(self) -> csr_matrix:
+        return csr_matrix(self.toarray())
+
+    def to_tensor(self) -> Tensor:
+        return Tensor(self.toarray().astype(np.float32))
+
+    @property
+    def nnz(self) -> int:
+        return len(self.data)