implemented the reader based on MultiTaskReader

.gitignore

@@ -8,4 +8,5 @@ neo_1month/
 __pycache__
 *.pyc
 dataset/
+*.ttf
 

neo_data_analysis.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cf0b3146625724c73369a3e064e940f9a5e4fe349d653b322de1fd4e3bf396f
+size 50024

neo_reader/__init__.py

@@ -1,3 +1,14 @@
 """init file"""
-from .neo_reader import NEOReader
+from .multitask_dataset import MultiTaskDataset
 from .neo_node import NEONode
+
+# For both 1month and 1week datasets
+_name_to_type = {"AOD": "AerosolOpticalDepth", "BS_ALBEDO": "Albedo", "CHLORA": "Chlorophyll",
+                "CLD_FR": "CloudFraction", "CLD_RD": "CloudParticleRadius", "CLD_WP": "CloudWaterContent",
+                "COT": "CloudOpticalThickness", "CO_M": "CarbonMonoxide", "FIRE": "Fire",
+                "INSOL": "SolarInsolation", "LAI": "LeafAreaIndex", "LSTD": "Temperature",
+                "LSTD_AN": "TemperatureAnomaly", "LSTN": "Temperature", "LSTN_AN": "TemperatureAnomaly",
+                "LWFLUX": "OutgoingLongwaveRadiation", "NDVI": "Vegetation", "NETFLUX": "NetRadiation",
+                "NO2": "NitrogenDioxide", "OZONE": "Ozone", "SNOWC": "SnowCover", "SST": "SeaSurfaceTemperature",
+                "SWFLUX": "ReflectedShortwaveRadiation", "WV": "WaterVapor"}
+neo_task_types = {k: NEONode(v, k) for k, v in _name_to_type.items()}

neo_reader/multitask_dataset.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""MultiTask Dataset module compatible with torch.utils.data.Dataset & DataLoader."""
+from __future__ import annotations
+from pathlib import Path
+from argparse import ArgumentParser
+from pprint import pprint
+from natsort import natsorted
+from loguru import logger
+import torch as tr
+import numpy as np
+from torch.utils.data import Dataset, DataLoader
+from lovely_tensors import monkey_patch
+
+monkey_patch()
+BuildDatasetTuple = tuple[dict[str, list[Path]], list[str]]
+MultiTaskItem = tuple[dict[str, tr.Tensor], str, list[str]] # [{task: data}, stem(name) | list[stem(name)], [tasks]]
+
+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):
+        self.name = name
+
+    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"] # in case on npz, we need this as well
+        return tr.from_numpy(data) # can be uint8, float16, float32 etc.
+
+    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().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)
+        if len(x.shape) == 2: x = x.unsqueeze(-1)
+        assert len(x.shape) == 3, x.shape # guaranteed to be (H, W, C) at this point
+        if x.shape[-1] != 3: x = x[..., 0:1]
+        if x.shape[-1] == 1: x = x.repeat(1, 1, 3)
+        x = x.nan_to_num(0).cpu().numpy() # guaranteed to be (H, W, 3) at this point hopefully
+        _min, _max = x.min((0, 1), keepdims=True), x.max((0, 1), keepdims=True)
+        if x.dtype != np.uint8: x = np.nan_to_num((x - _min) / (_max - _min) * 255, 0).astype(np.uint8)
+        return x
+
+    def __repr__(self):
+        return str(self)
+
+    def __str__(self):
+        return f"{str(type(self)).split('.')[-1][0:-2]}({self.name})"
+
+class MultiTaskDataset(Dataset):
+    """
+    MultiTaskDataset implementation. Reads data from npz files and returns them as a dict.
+
+    Parameters:
+    - path: Path to the directory containing the npz files.
+    - task_names: List of tasks that are present in the dataset. If set to None, will infer from the files on disk.
+    - handle_missing_data: Modes to handle missing data. Valid options are:
+      - drop: Drop the data point if any of the representations is missing.
+      - fill_none: Fill the missing data with Nones.
+
+    Expected directory structure:
+    path/
+    - task_1/0.npz, ..., N.npz
+    - ...
+    - task_n/0.npz, ..., N.npz
+
+    Names can be in a different format (i.e. 2022-01-01.npz), but must be consistent and equal across all tasks.
+    """
+
+    def __init__(self, path: Path, task_names: list[str] | None = None, handle_missing_data: str = "fill_none",
+                 files_suffix: str = "npz", task_types: dict[str, type] = None):
+        assert Path(path).exists(), f"Provided path '{path}' doesn't exist!"
+        assert handle_missing_data in ("drop", "fill_none"), f"Invalid handle_missing_data mode: {handle_missing_data}"
+        assert files_suffix == "npz", "Only npz supported right now (though trivial to update)"
+        self.path = Path(path).absolute()
+        self.handle_missing_data = handle_missing_data
+        self.suffix = files_suffix
+        self.all_files_per_repr = self._get_all_npz_files()
+        self.files_per_repr, self.file_names = self._build_dataset() # these are filtered by 'drop' or 'fill_none' logic
+        if task_types is None:
+            logger.debug("No explicit task types. Defaulting all of them to NpzRepresentation.")
+            task_types = {}
+
+        if task_names is None:
+            task_names = list(self.files_per_repr.keys())
+            logger.debug(f"No explicit tasks provided. Using all of them as read from the paths ({len(task_names)}).")
+        self.task_types = {k: task_types.get(k, NpzRepresentation) for k in task_names}
+        assert all(isinstance(x, str) for x in task_names), tuple(zip(task_names, (type(x) for x in task_names)))
+        self.task_names = sorted(task_names)
+        self._data_shape: tuple[int, ...] | None = None
+        self._tasks: list[NpzRepresentation] | None = None
+        self.name_to_task = {task.name: task for task in self.tasks}
+        logger.info(f"Tasks used in this dataset: {self.task_names}")
+
+    # Public methods and properties
+
+    @property
+    def data_shape(self) -> dict[str, tuple[int, ...]]:
+        """Returns a {task: shape_tuple} for all representations. At least one npz file must exist for each."""
+        first_npz = {task: [_v for _v in files if _v is not None][0] for task, files in self.files_per_repr.items()}
+        data_shape = {task: self.name_to_task[task].load_from_disk(first_npz[task]).shape for task in self.task_names}
+        return data_shape
+
+    @property
+    def tasks(self) -> list[NpzRepresentation]:
+        """
+        Returns a list of instantiated tasks in the same order as self.task_names. Overwrite this to add
+        new tasks and semantics (i.e. plot_fn or doing some preprocessing after loading from disk in some tasks.
+        """
+        if self._tasks is not None:
+            return self._tasks
+        self._tasks = []
+        for task_name in self.task_names:
+            t = self.task_types[task_name]
+            if not isinstance(t, NpzRepresentation):
+                t = t(task_name)
+            self._tasks.append(t)
+        assert all(t.name == t_n for t, t_n in zip(self._tasks, self.task_names)), (self._task_names, self._tasks)
+        return self._tasks
+
+    def collate_fn(self, items: list[MultiTaskItem]) -> MultiTaskItem:
+        """
+        given a list of items (i.e. from a reader[n:n+k] call), return the item batched on 1st dimension.
+        Nones (missing data points) are turned into zeros as per the data shape of that dim.
+        """
+        assert all(item[2] == self.task_names for item in items), ((item[2] for item in items), self.task_names)
+        items_name = [item[1] for item in items]
+        res = {k: tr.zeros(len(items), *self.data_shape[k]).float() for k in self.task_names} # float32 always
+        for i in range(len(items)):
+            for k in self.task_names:
+                res[k][i] = items[i][0][k] if items[i][0][k] is not None else float("nan")
+        return res, items_name, self.task_names
+
+    # Private methods
+
+    def _get_all_npz_files(self) -> dict[str, list[Path]]:
+        """returns a dict of form: {"rgb": ["0.npz", "1.npz", ..., "N.npz"]}"""
+        in_files = {}
+        all_repr_dirs: list[str] = [x.name for x in self.path.iterdir() if x.is_dir()]
+        for repr_dir_name in all_repr_dirs:
+            dir_name = self.path / repr_dir_name
+            if all(f.is_dir() for f in dir_name.iterdir()): # dataset is stored as repr/part_x/0.npz, ..., part_k/n.npz
+                all_files = []
+                for part in dir_name.iterdir():
+                    all_files.extend(part.glob(f"*.{self.suffix}"))
+            else: # dataset is stored as repr/0.npz, ..., repr/n.npz
+                all_files = dir_name.glob(f"*.{self.suffix}")
+            in_files[repr_dir_name] = natsorted(all_files, key=lambda x: x.name) # important: use natsorted() here
+        assert not any(len(x) == 0 for x in in_files.values()), f"{ [k for k, v in in_files.items() if len(v) == 0] }"
+        return in_files
+
+    def _build_dataset_drop(self) -> BuildDatasetTuple:
+        in_files = self.all_files_per_repr
+        name_to_node_path = {k: {_v.name: _v for _v in v} for k, v in in_files.items()} # {node: {name: path}}
+        common = set(x.name for x in next(iter(in_files.values())))
+        nodes = in_files.keys()
+        for node in nodes:
+            common = common.intersection([f.name for f in in_files[node]])
+            assert len(common) > 0, f"Node '{node}' made the intersection null"
+        common = natsorted(list(common))
+        logger.info(f"Found {len(common)} data points for each node ({len(nodes)} nodes).")
+        files_per_repr = {node: [name_to_node_path[node][x] for x in common] for node in nodes}
+        assert len(files_per_repr) > 0
+        return files_per_repr, common
+
+    def _build_dataset_fill_none(self) -> BuildDatasetTuple:
+        in_files = self.all_files_per_repr
+        name_to_node_path = {k: {_v.name: _v for _v in v} for k, v in in_files.items()}
+        all_files = set(x.name for x in next(iter(in_files.values())))
+        nodes = in_files.keys()
+        for node in nodes:
+            all_files = all_files.union([f.name for f in in_files[node]])
+        all_files = natsorted(list(all_files))
+        logger.info(f"Found {len(all_files)} data points as union of all nodes' data ({len(nodes)} nodes).")
+
+        files_per_repr = {node: [] for node in nodes}
+        for node in nodes:
+            for file_name in all_files:
+                file_path = name_to_node_path[node].get(file_name, None)
+                files_per_repr[node].append(file_path)
+        assert len(files_per_repr) > 0
+        return files_per_repr, all_files
+
+    def _build_dataset(self) -> BuildDatasetTuple:
+        logger.debug(f"Building dataset from: '{self.path}'")
+        if self.handle_missing_data == "drop":
+            return self._build_dataset_drop()
+        else:
+            return self._build_dataset_fill_none()
+
+    # Python magic methods (pretty printing the reader object, reader[0], len(reader) etc.)
+
+    def __getitem__(self, index: int | slice | list[int] | tuple) -> MultiTaskItem:
+        """Read the data all the desired nodes"""
+        assert isinstance(index, (int, slice, list, tuple)), type(index)
+        if isinstance(index, slice):
+            assert index.start is not None and index.stop is not None and index.step is None, "Only reader[l:r] allowed"
+            index = list(range(index.stop)[index])
+        if isinstance(index, (list, tuple)):
+            return self.collate_fn([self.__getitem__(ix) for ix in index])
+        res = {}
+        item_name = self.file_names[index]
+
+        for _repr in self.tasks:
+            file_path = self.files_per_repr[_repr.name][index]
+            file_path = file_path.resolve() if file_path is not None else None
+            assert self.handle_missing_data == "fill_none" or (file_path is not None and file_path.exists()), item_name
+            item = _repr.load_from_disk(file_path) if file_path is not None and file_path.exists() else None
+            res[_repr.name] = item
+        return (res, item_name, self.task_names)
+
+    def __len__(self) -> int:
+        return len(self.files_per_repr[self.task_names[0]]) # all of them have the same number (filled with None or not)
+
+    def __str__(self):
+        f_str = f"[{str(type(self)).rsplit('.', maxsplit=1)[-1][0:-2]}]"
+        f_str += f"\n - Path: '{self.path}'"
+        f_str += f"\n - Only full data: {self.handle_missing_data == 'drop'}"
+        f_str += f"\n - Representations ({len(self.tasks)}): {self.tasks}"
+        f_str += f"\n - Length: {len(self)}"
+        return f_str
+
+    def __repr__(self):
+        return str(self)
+
+def main():
+    """main fn"""
+    parser = ArgumentParser()
+    parser.add_argument("dataset_path", type=Path)
+    parser.add_argument("--handle_missing_data", choices=("drop", "fill_none"), default="fill_none")
+    args = parser.parse_args()
+
+    reader = MultiTaskDataset(args.dataset_path, task_names=None, handle_missing_data=args.handle_missing_data)
+    print(reader)
+    print(f"Shape: {reader.data_shape}")
+
+    rand_ix = np.random.randint(len(reader))
+    data, name, repr_names = reader[rand_ix] # get a random single data point
+    print(f"Name: {name}. Nodes: {repr_names}")
+    pprint({k: v for k, v in data.items()})
+
+    data, name, repr_names = reader[rand_ix: min(len(reader), rand_ix + 5)] # get a random batch
+    print(f"Name: {name}. Nodes: {repr_names}")
+    pprint({k: v for k, v in data.items()}) # Nones are converted to 0s automagically
+
+    loader = DataLoader(reader, collate_fn=reader.collate_fn, batch_size=5, shuffle=True)
+    data, name, repr_names = next(iter(loader)) # get a random batch using torch DataLoader
+    print(f"Name: {name}. Nodes: {repr_names}")
+    pprint({k: v for k, v in data.items()}) # Nones are converted to 0s automagically
+
+if __name__ == "__main__":
+    main()

neo_reader/neo_node.py

@@ -2,6 +2,10 @@
 from pathlib import Path
 import numpy as np
 from codecs import encode
+from overrides import overrides
+import torch as tr
+
+from .multitask_dataset import NpzRepresentation
 
 def _cmap_hex_to_rgb(hex_list):
     res = []
@@ -28,7 +32,7 @@ def _act_to_cmap(act_file: Path) -> np.ndarray:
     rgb_colors = _cmap_hex_to_rgb(hex_colors)
     return rgb_colors
 
-class NEONode:
+class NEONode(NpzRepresentation):
     """NEO nodes implementation in ngclib repository"""
     def __init__(self, node_type: str, name: str):
         # all neo nodes have 1 dimension.
@@ -42,30 +46,25 @@ class NEONode:
         self.name = name
         self.cmap = _act_to_cmap(Path(__file__).absolute().parent / "cmaps" / f"{self.node_type}.act")
 
-    def load_from_disk(self, x: np.ndarray) -> np.ndarray:
-        y: np.ndarray = np.float32(x)
+    @overrides
+    def load_from_disk(self, path: Path) -> tr.Tensor:
+        data = np.load(path, allow_pickle=False)
+        y = data if isinstance(data, np.ndarray) else data["arr_0"] # in case on npz, we need this as well
         if y.shape[0] == 1: # pylint: disable=unsubscriptable-object
             y = y[0] # pylint: disable=unsubscriptable-object
         if len(y.shape) == 2:
             y = np.expand_dims(y, axis=-1)
         y[np.isnan(y)] = 0
-        return y.astype(np.float32)
+        return tr.from_numpy(y).float()
 
-    def save_to_disk(self, x: np.ndarray) -> np.ndarray:
-        return x.clip(0, 1)
+    @overrides
+    def save_to_disk(self, data: tr.Tensor, path: Path):
+        return super().save_to_disk(data.clip(0, 1), path)
 
-    def plot_fn(self, x: np.ndarray | None) -> np.ndarray | None:
-        if x is None:
-            return x
-        y = np.clip(x, 0, 1)
+    def plot_fn(self, x: tr.Tensor) -> np.ndarray:
+        y = np.clip(x.numpy(), 0, 1)
         y = y * 255
         y[y == 0] = 255
         y = y.astype(np.uint).squeeze()
         y_rgb = self.cmap[y].astype(np.uint8)
         return y_rgb
-
-    def __repr__(self):
-        return self.name
-
-    def __str__(self):
-        return f"NEONode({self.name})"

neo_reader/neo_reader.py

@@ -1,183 +0,0 @@
-#!/usr/bin/env python3
-"""NEO Reader module"""
-from __future__ import annotations
-from pathlib import Path
-from argparse import Namespace, ArgumentParser
-from pprint import pprint
-from natsort import natsorted
-from loguru import logger
-import numpy as np
-from torch.utils.data import Dataset
-
-try:
-    from .neo_node import NEONode
-except ImportError:
-    from neo_node import NEONode
-
-class NEOReader(Dataset):
-    """
-    NEO Reader implementation. Reads data from npz files and returns them as a dict.
-
-    Parameters:
-    - path: Path to the directory containing the npz files.
-    - nodes: List of nodes that are present in the dataset.
-    - handle_missing_data: Modes to handle missing data. Valid options are:
-      - drop: Drop the data point if any of the nodes is missing.
-      - fill_none: Fill the missing data with Nones.
-
-    Expected directory structure:
-    path/
-    - node_1/0.npz, ..., N.npz
-    - ...
-    - node_n/0.npz, ..., N.npz
-
-    Names can be in a different format (i.e. 2022-01-01.npz), but must be consistent and equal across all nodes.
-    """
-    # The default names and their corresponding types for NEO datasets (1week or 1month)
-    name_to_type = {"AOD": "AerosolOpticalDepth", "BS_ALBEDO": "Albedo", "CHLORA": "Chlorophyll",
-                    "CLD_FR": "CloudFraction", "CLD_RD": "CloudParticleRadius", "CLD_WP": "CloudWaterContent",
-                    "COT": "CloudOpticalThickness", "CO_M": "CarbonMonoxide", "FIRE": "Fire",
-                    "INSOL": "SolarInsolation", "LAI": "LeafAreaIndex", "LSTD": "Temperature",
-                    "LSTD_AN": "TemperatureAnomaly", "LSTN": "Temperature", "LSTN_AN": "TemperatureAnomaly",
-                    "LWFLUX": "OutgoingLongwaveRadiation", "NDVI": "Vegetation", "NETFLUX": "NetRadiation",
-                    "NO2": "NitrogenDioxide", "OZONE": "Ozone", "SNOWC": "SnowCover", "SST": "SeaSurfaceTemperature",
-                    "SWFLUX": "ReflectedShortwaveRadiation", "WV": "WaterVapor"}
-
-    def __init__(self, path: Path, nodes: list[str] | None = None, handle_missing_data: str = "fill_none"):
-        assert path.exists(), f"Provided path '{path}' doesn't exist!"
-        assert handle_missing_data in ("drop", "fill_none"), f"Invalid handle_missing_data mode: {handle_missing_data}"
-        self.path = Path(path).absolute()
-        self.files_per_node, self.file_names = self._build_dataset(handle_missing_data)
-        if nodes is None:
-            nodes = list(self.files_per_node.keys())
-            logger.debug("No nodes provided. Using all of them as read from the paths.")
-        assert all(isinstance(x, str) for x in nodes), tuple(zip(nodes, (type(x) for x in nodes)))
-
-        self.node_names = sorted(nodes)
-        logger.info(f"Nodes used in this reader: {self.node_names}")
-        self.nodes = [NEONode(NEOReader.name_to_type[x], x) for x in self.node_names]
-        self.handle_missing_data = handle_missing_data
-
-        self._images_shape: tuple[int, int, int] | None = None
-
-    # Public methods and properties
-
-    @property
-    def images_shape(self) -> tuple[int, int, int]:
-        """Returns a triple of (H, W, C) for all images shape, which are assumed to be consistent for all data points"""
-        if self._images_shape is None:
-            i = 0
-            while True:
-                for img in self[i][0].values():
-                    if img is not None:
-                        self._images_shape = img.shape
-                        assert len(self._images_shape) == 3 and self._images_shape[-1] == 1, self._images_shape
-                        return self._images_shape
-                i += 1
-        return self._images_shape
-
-    # Private methods
-
-    def _get_all_npz_files(self) -> dict[str, list[Path]]:
-        in_files = {}
-        nodes = [x for x in self.path.iterdir() if x.is_dir()]
-        for node in nodes:
-            dir_name = self.path / node.name
-            items = dir_name.glob("*.npz")
-            items = set(natsorted(items, key=lambda x: x.name))
-            in_files[node.name] = items
-        assert not any(len(x) == 0 for x in in_files.values()), f"{ [k for k, v in in_files.items() if len(v) == 0] }"
-        return in_files
-
-    def _build_dataset_drop(self) -> tuple[dict[str, list[Path]], list[str]]:
-        in_files = self._get_all_npz_files()
-        common = set(x.name for x in next(iter(in_files.values())))
-        nodes = in_files.keys()
-        for node in nodes:
-            common = common.intersection([f.name for f in in_files[node]])
-            assert len(common) > 0, f"Node '{node}' made the intersection null"
-        common = natsorted(list(common))
-        logger.info(f"Found {len(common)} data points for each node ({len(nodes)} nodes).")
-        files_per_node = {node: [self.path / node / x for x in common] for node in nodes}
-        return files_per_node, common
-
-    def _build_dataset_fill_none(self) -> tuple[dict[str, list[Path]], list[str]]:
-        in_files = self._get_all_npz_files()
-        all_files = set(x.name for x in next(iter(in_files.values())))
-        nodes = in_files.keys()
-        for node in nodes:
-            all_files = all_files.union([f.name for f in in_files[node]])
-        all_files = natsorted(list(all_files))
-        logger.info(f"Found {len(all_files)} data points as union of all nodes' data ({len(nodes)} nodes).")
-
-        files_per_node = {node: [] for node in nodes}
-        in_file_names = {node: [f.name for f in in_files[node]] for node in nodes}
-        for node in nodes:
-            for file_name in all_files:
-                file_path = self.path / node / file_name if file_name in in_file_names[node] else None
-                files_per_node[node].append(file_path)
-        return files_per_node, all_files
-
-    def _build_dataset(self, handle_missing_data: str) -> tuple[dict[str, list[Path]], list[str]]:
-        logger.debug(f"Building dataset from: '{self.path}'")
-        if handle_missing_data == "drop":
-            return self._build_dataset_drop()
-        else:
-            return self._build_dataset_fill_none()
-
-    def _read_node_data(self, node: NEONode, index: int) -> np.ndarray | None:
-        """Reads the npz data from the disk and transforms it properly"""
-        file_path = self.files_per_node[node.name][index]
-        if file_path is None:
-            return None
-        item = np.load(file_path, allow_pickle=True)["arr_0"]
-        transformed_item = node.load_from_disk(item)
-        return transformed_item
-
-    # Python magic methods (pretty printing the reader object, reader[0], len(reader) etc.)
-
-    def __getitem__(self, index: int) -> tuple[dict[str, np.ndarray], str, list[str]]:
-        """Read the data all the desired nodes"""
-        assert isinstance(index, int), type(index)
-        res = {}
-        item_name = self.file_names[index]
-
-        for node in self.nodes:
-            item = self._read_node_data(node, index)
-            assert self.handle_missing_data == "fill_none" or item is not None, item_name
-            res[node.name] = item
-        return (res, item_name, self.node_names)
-
-    def __len__(self) -> int:
-        return len(self.files_per_node[self.node_names[0]])
-
-    def __str__(self):
-        f_str = "[NGC Npz Reader]"
-        f_str += f"\n - Path: '{self.path}'"
-        f_str += f"\n - Only full data: {self.handle_missing_data == 'drop'}"
-        f_str += f"\n - Nodes ({len(self.nodes)}): {self.nodes}"
-        f_str += f"\n - Length: {len(self)}"
-        return f_str
-
-    def __repr__(self):
-        return str(self)
-
-def get_args() -> Namespace:
-    """cli args"""
-    parser = ArgumentParser()
-    parser.add_argument("dataset_path", type=Path)
-    parser.add_argument("--handle_missing_data", choices=("drop", "fill_none"), default="fill_none")
-    args = parser.parse_args()
-    return args
-
-def main(args: Namespace):
-    """main fn"""
-    reader = NEOReader(args.dataset_path, nodes=None, handle_missing_data=args.handle_missing_data)
-    print(reader)
-    print(f"Shape: {reader.images_shape}")
-    data, name, node_names = reader[np.random.randint(len(reader))]
-    print(f"Name: {name}. Nodes: {node_names}")
-    pprint({k: (v.shape if v is not None else None) for k, v in data.items()})
-
-if __name__ == "__main__":
-    main(get_args())

neo_viewer.ipynb

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:23c8ec700dc0df69d0ee88c6c0998e287fc76ef21b0ce2fc31d5697fb283e8b5
-size 11757180
+oid sha256:694e5b784a08a3aaa7f30d68026a80ba9dc7dd247912f038339bee9a24ba7673
+size 12434984