|
"""MultiTask representations stored as .npz files on the disk""" |
|
from __future__ import annotations |
|
from pathlib import Path |
|
import numpy as np |
|
import torch as tr |
|
|
|
class NpzRepresentation: |
|
"""Generic Task with data read from/saved to npz files. Tries to read data as-is from disk and store it as well""" |
|
def __init__(self, name: str, n_channels: int, dependencies: list[NpzRepresentation] | None = None): |
|
self.name = name |
|
self.n_channels = n_channels |
|
dependencies = deps = [self] if dependencies is None else dependencies |
|
self.dependencies: list[NpzRepresentation] = dependencies |
|
assert all(isinstance(dep, NpzRepresentation) for dep in deps), f"{self}: {dict(zip(deps, map(type, deps)))}" |
|
self.classes: list[str] | None = None |
|
self.normalization: str | None = None |
|
self.min: tr.Tensor | None = None |
|
self.max: tr.Tensor | None = None |
|
self.mean: tr.Tensor | None = None |
|
self.std: tr.Tensor | None = None |
|
|
|
@property |
|
def is_classification(self) -> bool: |
|
"""if we have self.classes""" |
|
return self.classes is not None |
|
|
|
@property |
|
def dep_names(self) -> list[str]: |
|
"""The names of the dependencies of this representation""" |
|
return [dep.name for dep in self.dependencies] |
|
|
|
def set_normalization(self, normalization: str, stats: tuple[tr.Tensor, tr.Tensor, tr.Tensor, tr.Tensor]): |
|
"""sets the normalization""" |
|
assert normalization in ("min_max", "standardization"), normalization |
|
assert isinstance(stats, tuple) and len(stats) == 4, stats |
|
self.normalization = normalization |
|
self.min, self.max, self.mean, self.std = stats |
|
|
|
def load_from_disk(self, path: Path) -> tr.Tensor: |
|
"""Reads the npz data from the disk and transforms it properly""" |
|
data = np.load(path, allow_pickle=False) |
|
data = data if isinstance(data, np.ndarray) else data["arr_0"] |
|
data = data.astype(np.float32) if np.issubdtype(data.dtype, np.floating) else data |
|
res = tr.from_numpy(data) |
|
res = res.unsqueeze(-1) if len(res.shape) == 2 and self.n_channels == 1 else res |
|
assert ((res.shape[-1] == self.n_channels and len(res.shape) == 3) or |
|
(len(res.shape) == 2 and self.is_classification)), f"{self.name}: {res.shape} vs {self.n_channels}" |
|
return res |
|
|
|
def save_to_disk(self, data: tr.Tensor, path: Path): |
|
"""stores this item to the disk which can then be loaded via `load_from_disk`""" |
|
np.save(path, data.cpu().detach().numpy(), allow_pickle=False) |
|
|
|
def plot_fn(self, x: tr.Tensor) -> np.ndarray: |
|
"""very basic implementation of converting this representation to a viewable image. You should overwrite this""" |
|
assert isinstance(x, tr.Tensor), type(x) |
|
assert len(x.shape) == 3, x.shape |
|
x = x.nan_to_num(0).cpu().detach() |
|
if x.shape[-1] != 3: |
|
x = x[..., 0:1] |
|
if x.shape[-1] == 1: |
|
x = x.repeat(1, 1, 3) |
|
if x.dtype == tr.uint8 or self.is_classification: |
|
return x.numpy() |
|
if self.normalization is not None: |
|
x = (x * self.std + self.mean) if self.normalization == "standardization" else x |
|
x = x * (self.max - self.min) + self.min if self.normalization == "min_max" else x |
|
x = (x * 255) if (self.max <= 1).any() else x |
|
x = x.numpy().astype(np.uint8) |
|
return x |
|
|
|
def normalize(self, x: tr.Tensor) -> tr.Tensor: |
|
"""normalizes a data point read with self.load_from_disk(path) using external min/max information""" |
|
assert self.min is not None, "self.statistics must be set from reader before task.normalize(x)" |
|
return ((x.float() - self.min) / (self.max - self.min)).nan_to_num(0, 0, 0).float() |
|
|
|
def standardize(self, x: tr.Tensor) -> tr.Tensor: |
|
"""standardizes a data point read with self.load_from_disk(path) using external min/max information""" |
|
assert self.min is not None, "self.statistics must be set from reader before task.normalize(x)" |
|
res = ((x.float() - self.mean) / self.std).nan_to_num(0, 0, 0) |
|
res[(res < -10) | (res > 10)] = 0 |
|
return res.float() |
|
|
|
def __repr__(self): |
|
return str(self) |
|
|
|
def __str__(self): |
|
return f"{str(type(self)).split('.')[-1][0:-2]}({self.name}[{self.n_channels}])" |
|
|
