spikezoo 0.1__py3-none-any.whl

spikezoo/pipeline/ensemble_pipeline.py

@@ -0,0 +1,64 @@
+import torch
+from dataclasses import dataclass, field
+import os
+from spikezoo.utils.img_utils import tensor2npy, AverageMeter
+from spikezoo.utils.spike_utils import load_vidar_dat
+from spikezoo.metrics import cal_metric_pair, cal_metric_single
+import numpy as np
+import cv2
+from pathlib import Path
+from enum import Enum, auto
+from typing import Literal
+from spikezoo.metrics import metric_pair_names, metric_single_names, metric_all_names
+from thop import profile
+import time
+from datetime import datetime
+from spikezoo.utils import setup_logging, save_config
+from tqdm import tqdm
+from spikezoo.models import build_model_cfg, build_model_name, BaseModel, BaseModelConfig
+from spikezoo.datasets import build_dataset_cfg, build_dataset_name, BaseDataset, BaseDatasetConfig, build_dataloader
+from typing import Optional, Union, List
+from spikezoo.pipeline.base_pipeline import Pipeline, PipelineConfig
+
+
+@dataclass
+class EnsemblePipelineConfig(PipelineConfig):
+    _mode: Literal["single_mode", "multi_mode", "train_mode"] = "multi_mode"
+
+
+class EnsemblePipeline(Pipeline):
+    def __init__(
+        self,
+        cfg: PipelineConfig,
+        model_cfg_list: Union[List[str], List[BaseModelConfig]],
+        dataset_cfg: Union[str, BaseDatasetConfig],
+    ):
+        self.cfg = cfg
+        self._setup_model_data(model_cfg_list,dataset_cfg)
+        self._setup_pipeline()
+
+    def _setup_model_data(self,model_cfg_list,dataset_cfg):
+        """Model and Data setup."""
+        # model
+        self.model_list: List[BaseModel] = (
+            [build_model_name(name) for name in model_cfg_list] if isinstance(model_cfg_list[0],str) else [build_model_cfg(cfg) for cfg in model_cfg_list]
+        )
+        self.model_list = [model.eval() for model in self.model_list]
+        torch.set_grad_enabled(False)
+        # data
+        self.dataset: BaseDataset = build_dataset_name(dataset_cfg) if isinstance(dataset_cfg, str) else build_dataset_cfg(dataset_cfg)
+        self.dataloader = build_dataloader(self.dataset)
+        # device
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+    
+    def _spk2img(self, spike, img, save_folder):
+        for model in self.model_list:
+            self._spk2img_model(model, spike, img, save_folder)
+
+    def cal_params(self):
+        for model in self.model_list:
+            self._cal_prams_model(model)
+
+    def cal_metrics(self):
+        for model in self.model_list:
+            self._cal_metrics_model(model)

spikezoo/pipeline/train_pipeline.py

@@ -0,0 +1,94 @@
+import torch
+from dataclasses import dataclass
+import os
+from spikezoo.utils.img_utils import tensor2npy
+import cv2
+from pathlib import Path
+from typing import Literal
+from tqdm import tqdm
+from spikezoo.models import build_model_cfg, build_model_name, BaseModel, BaseModelConfig
+from spikezoo.datasets import build_dataset_cfg, build_dataset_name, BaseDataset, BaseDatasetConfig, build_dataloader
+from typing import  Union
+from spikezoo.pipeline.base_pipeline import Pipeline, PipelineConfig
+
+
+@dataclass
+class TrainPipelineConfig(PipelineConfig):
+    bs_train: int = 4
+    epochs: int = 100
+    lr: float = 1e-3
+    num_workers: int = 4
+    pin_memory: bool = False
+    steps_per_save_imgs = 10
+    steps_per_cal_metrics = 10
+    _mode: Literal["single_mode", "multi_mode", "train_mode"] = "train_mode"
+
+
+class TrainPipeline(Pipeline):
+    def __init__(
+        self,
+        cfg: TrainPipelineConfig,
+        model_cfg: Union[str, BaseModelConfig],
+        dataset_cfg: Union[str, BaseDatasetConfig],
+    ):
+        self.cfg = cfg
+        self._setup_model_data(model_cfg, dataset_cfg)
+        self._setup_pipeline()
+        self.model.setup_training(cfg)
+
+    def _setup_model_data(self, model_cfg, dataset_cfg):
+        """Model and Data setup."""
+        # model
+        self.model: BaseModel = build_model_name(model_cfg) if isinstance(model_cfg, str) else build_model_cfg(model_cfg)
+        self.model = self.model.train()
+        torch.set_grad_enabled(True)
+        # data
+        if isinstance(dataset_cfg, str):
+            self.train_dataset: BaseDataset = build_dataset_name(dataset_cfg, split="train")
+            self.dataset: BaseDataset = build_dataset_name(dataset_cfg, split="test")
+        else:
+            self.train_dataset: BaseDataset = build_dataset_cfg(dataset_cfg, split="train")
+            self.dataset: BaseDataset = build_dataset_cfg(dataset_cfg, split="test")
+        self.train_dataloader = build_dataloader(self.train_dataset, self.cfg)
+        self.dataloader = build_dataloader(self.dataset)
+        # device
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    def save_network(self, epoch):
+        """Save the network."""
+        save_folder = self.save_folder / Path("ckpt")
+        os.makedirs(save_folder, exist_ok=True)
+        self.model.save_network(save_folder / f"{epoch:06d}.pth")
+
+    def save_visual(self, epoch):
+        """Save the visual results."""
+        self.logger.info("Saving visual results...")
+        save_folder = self.save_folder / Path("imgs") / Path(f"{epoch:06d}")
+        os.makedirs(save_folder, exist_ok=True)
+        for batch_idx, batch in enumerate(tqdm(self.dataloader)):
+            if batch_idx % (len(self.dataloader) // 4) == 0:
+                continue 
+            batch = self.model.feed_to_device(batch)
+            outputs = self.model.get_outputs_dict(batch)
+            visual_dict = self.model.get_visual_dict(batch, outputs)
+            # save
+            for key, img in visual_dict.items():
+                cv2.imwrite(str(save_folder / Path(f"{batch_idx:06d}_{key}.png")), tensor2npy(img))
+
+    def train(self):
+        """Training code."""
+        self.logger.info("Start Training!")
+        for epoch in range(self.cfg.epochs):
+            # training
+            for batch_idx, batch in enumerate(tqdm(self.train_dataloader)):
+                batch = self.model.feed_to_device(batch)
+                outputs = self.model.get_outputs_dict(batch)
+                loss_dict, loss_values_dict = self.model.get_loss_dict(outputs, batch)
+                self.model.optimize_parameters(loss_dict)
+            self.model.update_learning_rate()
+            self.logger.info(f"EPOCH {epoch}/{self.cfg.epochs}: Train Loss: {loss_values_dict}")
+            #  save visual results & evaluate metrics
+            if epoch % self.cfg.steps_per_save_imgs == 0 or epoch == self.cfg.epochs - 1:
+                self.save_visual(epoch)
+            if epoch % self.cfg.steps_per_cal_metrics == 0 or epoch == self.cfg.epochs - 1:
+                self.cal_metrics()

spikezoo/utils/__init__.py

@@ -0,0 +1,3 @@
+from .spike_utils import load_vidar_dat
+from .img_utils import load_network,tensor2npy
+from .other_utils import setup_logging,save_config,download_file

spikezoo/utils/data_utils.py

@@ -0,0 +1,52 @@
+import queue as Queue
+import threading
+import torch
+from torch.utils.data import DataLoader
+import math
+import random
+
+class Augmentor:
+    def __init__(self, crop_size = (-1,-1)):
+        self.crop_size = crop_size
+         
+    def augment(self, img, mode=0):
+        mode = mode - mode % 2 if self.use_rot == False else mode
+        if mode == 0:
+            return img
+        elif mode == 1:
+            return torch.flip(torch.rot90(img, 1, [1, 2]), [1])  # flipud + rot90(k=1)
+        elif mode == 2:
+            return torch.flip(img, [1])  # flipud
+        elif mode == 3:
+            return torch.rot90(img, 3, [1, 2])  # rot90(k=3)
+        elif mode == 4:
+            return torch.flip(torch.rot90(img, 2, [1, 2]), [1])  # flipud + rot90(k=2)
+        elif mode == 5:
+            return torch.rot90(img, 1, [1, 2])  # rot90(k=1)
+        elif mode == 6:
+            return torch.rot90(img, 2, [1, 2])  # rot90(k=2)
+        elif mode == 7:
+            return torch.flip(torch.rot90(img, 3, [1, 2]), [1])  # flipud + rot90(k=3)
+        
+    def spatial_transform(self, spike, image):
+        mode = random.randint(0, 7)
+        spike_h = spike.shape[1]
+        spike_w = spike.shape[2]
+        # default mode
+        if self.crop_size != (-1,-1):
+            assert spike_h > self.crop_size[0] and spike_w > self.crop_size[1], f"ROI Size should be smaller than spike input size."
+            y0 = random.randint(0, spike_h - self.crop_size[0])
+            x0 = random.randint(0, spike_w - self.crop_size[1])
+            spike = spike[:,y0:y0+self.crop_size[0], x0:x0+self.crop_size[1]]
+            image = image[:,y0:y0+self.crop_size[0], x0:x0+self.crop_size[1]]
+        # rotation set
+        self.use_rot = True if image.shape[1] == image.shape[2] else False
+        # aug
+        spike = self.augment(spike, mode=mode)
+        image = self.augment(image, mode=mode)
+        return spike, image
+
+    def __call__(self, spike, image):
+        spike, image = self.spatial_transform(spike, image)
+        return spike, image
+

spikezoo/utils/img_utils.py

@@ -0,0 +1,72 @@
+import numpy as np
+import torch
+import torch.nn as nn
+from collections import OrderedDict
+from torch.nn.parallel import DistributedDataParallel 
+
+
+def tensor2npy(tensor,normalize = False):
+    """Convert the 0-1 torch float tensor to the 0-255 uint numpy array"""
+    if tensor.dim() == 4:
+        tensor = tensor[0,0]
+    tensor = tensor.clip(0, 1).detach().cpu().numpy()
+    if normalize == True:
+        tensor = (tensor - tensor.min()) / (tensor.max() - tensor.min())
+    tensor = 255 * tensor
+    return tensor.astype(np.uint8)
+
+
+class AverageMeter(object):
+    """Computes and stores the average and current value"""
+
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.val = 0
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+
+    def update(self, val, n=1):
+        self.val = val
+        self.count += n
+        self.sum += val * n
+        self.avg = self.sum / self.count
+        
+def load_network(load_path, network, strict=False):
+    # network multi-gpu training 
+    if isinstance(network, nn.DataParallel) or isinstance(network, DistributedDataParallel):
+        network = network.module
+    
+    # load .pt or .pth
+    if load_path.endswith('.pt') == True:
+        load_net = torch.load(load_path)
+        if isinstance(load_net, nn.DataParallel) or isinstance(load_net, DistributedDataParallel):
+            load_net = load_net.module
+        
+        if isinstance(load_net,nn.Module):
+            load_state = load_net.state_dict() 
+        else:
+            load_state = load_net
+    elif load_path.endswith('.pth') == True:
+        load_state = torch.load(load_path)
+
+    # clean multi-gpu state
+    load_state_clean = OrderedDict()  
+    for k, v in load_state.items():
+        if k.startswith('module.'):
+            load_state_clean[k[7:]] = v
+        else:
+            load_state_clean[k] = v
+            
+    # load the model_weight
+    if 'model_state_dict' in load_state_clean.keys():
+        network.load_state_dict(load_state_clean['model_state_dict'], strict=strict)
+    elif 'model' in load_state_clean.keys():
+        network.load_state_dict(load_state_clean['model'], strict=strict)
+    else:
+        network.load_state_dict(load_state_clean, strict=strict)
+    return network
+
+

spikezoo/utils/other_utils.py

@@ -0,0 +1,59 @@
+import logging
+from dataclasses import dataclass, field, asdict
+import requests
+from tqdm import tqdm
+import os
+
+
+# log info
+def setup_logging(log_file):
+    logger = logging.getLogger("training_logger")
+    logger.setLevel(logging.INFO)
+    logger.propagate = False
+    if logger.hasHandlers():
+        logger.handlers.clear()
+    file_handler = logging.FileHandler(log_file, mode="w")  # 使用'w'模式打开文件
+    file_handler.setLevel(logging.INFO)
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M")
+    file_handler.setFormatter(formatter)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+    return logger
+
+
+def save_config(cfg, filename, mode="w"):
+    """Save the config file to the given filename."""
+    filename = str(filename)
+    with open(filename, mode) as file:
+        for key, value in asdict(cfg).items():
+            file.write(f"{key} = {value}\n")
+        file.write("\n")
+
+
+def download_file(url, output_path):
+    headers = {
+        "sec-ch-ua": '" Not A;Brand";v="99", "Chromium";v="90", "Google Chrome";v="90"',
+        "sec-ch-ua-mobile": "?0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36"
+    }
+    try:
+        print(f"Ready to download the file from the {url} 😊😊😊.")
+        response = requests.head(url,headers=headers)
+        response.raise_for_status()
+        file_size = int(response.headers.get("Content-Length", 0))
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        if response.status_code == 200:
+            with open(output_path, "wb") as file, tqdm(desc="Downloading", total=file_size, unit="B", unit_scale=True) as bar:
+                for chunk in response.iter_content(chunk_size=1024):
+                    if chunk:
+                        file.write(chunk)
+                        bar.update(len(chunk))
+            print(f"Files downloaded successfully 🎉🎉🎉 and saved on {output_path}!")
+        else:
+            raise RuntimeError(f"Files fail to download 😔😔😔. Try downloading it from {url} and move it to {output_path}.")
+    except requests.exceptions.RequestException as e:
+        raise RuntimeError(f"Files fail to download 😔😔😔. Try downloading it from {url} and move it to {output_path}.")

spikezoo/utils/spike_utils.py

@@ -0,0 +1,82 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import os
+
+def load_vidar_dat(filename, height, width, remove_head=False, out_type="float", out_format="array"):
+    """Load the spike stream from the .dat file."""
+    # Spike decode
+    if isinstance(filename, str):
+        array = np.fromfile(filename, dtype=np.uint8)
+    elif isinstance(filename, (list, tuple)):
+        l = []
+        for name in filename:
+            a = np.fromfile(name, dtype=np.uint8)
+            l.append(a)
+        array = np.concatenate(l)
+    else:
+        raise NotImplementedError
+    len_per_frame = height * width // 8
+    framecnt = len(array) // len_per_frame
+    spikes = []
+    for i in range(framecnt):
+        compr_frame = array[i * len_per_frame : (i + 1) * len_per_frame]
+        blist = []
+        for b in range(8):
+            blist.append(np.right_shift(np.bitwise_and(compr_frame, np.left_shift(1, b)), b))
+        frame_ = np.stack(blist).transpose()
+        frame_ = np.flipud(frame_.reshape((height, width), order="C"))
+        spk = frame_.copy()[None]
+        spk = spk[:, :, :-16] if remove_head == True else spk
+        spikes.append(spk)
+    spikes = np.concatenate(spikes)
+
+    # Data type conversion
+    type_dict = {"float": np.float32, "int": np.uint8}
+    spikes = spikes.astype(type_dict[out_type])
+
+    # Output format conversion
+    format_dict = {"array": lambda x: x, "tensor": torch.from_numpy}
+    spikes = format_dict[out_format](spikes)
+    return spikes
+
+def SpikeToRaw(save_path, SpikeSeq, filpud=True, delete_if_exists=True):
+    """Save the spike sequence to the .dat file."""
+    if delete_if_exists:
+        if os.path.exists(save_path):
+            os.remove(save_path)
+    sfn, h, w = SpikeSeq.shape
+    remainder = int((h * w) % 8)
+    base = np.power(2, np.linspace(0, 7, 8))
+    fid = open(save_path, 'ab')
+    for img_id in range(sfn):
+        if filpud:
+            spike = np.flipud(SpikeSeq[img_id, :, :])
+        else:
+            spike = SpikeSeq[img_id, :, :]
+        if remainder == 0:
+            spike = spike.flatten()
+        else:
+            spike = np.concatenate([spike.flatten(), np.array([0]*(8-remainder))])
+        spike = spike.reshape([int(h*w/8), 8])
+        data = spike * base
+        data = np.sum(data, axis=1).astype(np.uint8)
+        fid.write(data.tobytes())
+    fid.close()
+    return
+
+def video2spike_simulation(imgs, threshold=2.0):
+    """Convert the images input to the spike stream."""
+    imgs = np.array(imgs)
+    T,H, W = imgs.shape
+    spike = np.zeros([T, H, W], np.uint8)
+    integral = np.random.random(size=([H,W])) * threshold
+    for t in range(0, T):
+        integral += imgs[t]
+        fire = (integral - threshold) >= 0
+        fire_pos = fire.nonzero()
+        integral[fire_pos] -= threshold
+        spike[t][fire_pos] = 1
+    return spike
+
+

spikezoo-0.1.dist-info/LICENSE.txt

@@ -0,0 +1,17 @@
+MIT License
+Copyright (c) 2018 YOUR NAME
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

spikezoo-0.1.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.2
+Name: spikezoo
+Version: 0.1
+Summary: A deep learning toolbox for spike-to-image models.
+Home-page: https://github.com/chenkang455/Spike-Zoo
+Author: Kang Chen
+Author-email: mrchenkang@stu.pku.edu.cn
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: torch
+Requires-Dist: requests
+Requires-Dist: numpy
+Requires-Dist: tqdm
+Requires-Dist: scikit-image
+Requires-Dist: lpips
+Requires-Dist: pyiqa
+Requires-Dist: opencv-python
+Requires-Dist: thop
+Requires-Dist: pytorch-wavelets
+Requires-Dist: pytz
+Requires-Dist: PyWavelets
+Requires-Dist: pandas
+Requires-Dist: pillow
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: spikingjelly
+Requires-Dist: setuptools
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+⚡Spike-Zoo is the go-to library for state-of-the-art pretrained **spike-to-image** models for reconstructing the image from the given spike stream. Whether you're looking for a **simple inference** solution or **training** your own spike-to-image models, ⚡Spike-Zoo is a modular toolbox that supports both. 
+

spikezoo-0.1.dist-info/RECORD

@@ -0,0 +1,36 @@
+spikezoo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spikezoo/archs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spikezoo/datasets/__init__.py,sha256=bnskj7Bo0cWEk8XEBjOB2etTOjtsoReOxjezeZmYyTs,3274
+spikezoo/datasets/base_dataset.py,sha256=oLBy8R_iZXloYZU-kcLyu680cSgs0J3KM62gAiHyL8E,5800
+spikezoo/datasets/realworld_dataset.py,sha256=iqn9oYu56Ph2nsA2U5aesTjflNmfr3-6krHVXC49ByM,715
+spikezoo/datasets/reds_small_dataset.py,sha256=nhX95iWAADlu65XCGsU8CosjLHvxzSgAumA4MDwaTUc,883
+spikezoo/datasets/szdata_dataset.py,sha256=2zLLKj6PC2XUcmgUMUqKKiA_zQZdZx7hCsI8Ft-i4o8,1230
+spikezoo/datasets/uhsr_dataset.py,sha256=cuQBEuOw0AFaxV-reLWqsS2KevKTYF2Pr8ak5dSlkbc,1166
+spikezoo/metrics/__init__.py,sha256=C1sX1sx7-UAvuR-LemYejWB9fsvl786IqIKA6LSY1so,3250
+spikezoo/models/__init__.py,sha256=ePC94bz7Yjvg_CQQSWCkb7J5E_Tc370408a9tkzDFDQ,1679
+spikezoo/models/base_model.py,sha256=zqlYuAHPqhLjG86V9qaY7xNUYs7fL3UnvjNdlojOlM0,6766
+spikezoo/models/bsf_model.py,sha256=KVKmukMfhr8hOIwIlWAKnCvDSHlXK2HJwjzP9bEGpNw,3523
+spikezoo/models/spcsnet_model.py,sha256=kLzv-ASXZGnqEFx0jUBONBeRCrsnQ_omkQUYEnr6uJc,540
+spikezoo/models/spikeclip_model.py,sha256=ltEbEb-TNyzHGWHgiOc6-701LSGvSHYiD1WXglwgOJM,1010
+spikezoo/models/spikeformer_model.py,sha256=oNwmzWNdemJhjDWnPoJwlxUzKLAAu9YpE2J9iwEkEoA,1586
+spikezoo/models/spk2imgnet_model.py,sha256=QknQeqLfZdU2MoToUsNqFvAGN0rN2-6wzOw6I4Xtqwc,1549
+spikezoo/models/ssir_model.py,sha256=sVLZ_7BwBqloB3H94BuQfyhbepwS1FdoEtbIkrPqQkk,586
+spikezoo/models/ssml_model.py,sha256=u_UohCL2Q_iRZ-I_udJiQ5_30_ZASKxhttDgJKLtZ6E,493
+spikezoo/models/stir_model.py,sha256=fXFajxWs2P4OoAPGXGkwOGJCDslWqJ4wus4mfbvvH7w,1176
+spikezoo/models/tfi_model.py,sha256=fLaBOz1f3c-wvA8bEYVfUNk9vgtbMhbS02-Xie294mg,536
+spikezoo/models/tfp_model.py,sha256=khG15qA_32PEb3BaYHFo5BzXUaxh-Napl_0bwXIcGz8,535
+spikezoo/models/wgse_model.py,sha256=9N1O_ucbdQ_lndLpWNjuhidyWKs8Ct8Wr-OWTYCVc44,860
+spikezoo/pipeline/__init__.py,sha256=WPsukNR4cannwsghiukqNsWbWGH5DVPapR_Ly-WOU4Q,188
+spikezoo/pipeline/base_pipeline.py,sha256=Lh00P5wzhPYJRCZryVYIREw5Wv9SN0xNKRGAf22rI_M,11993
+spikezoo/pipeline/ensemble_pipeline.py,sha256=Aoi0lLcSDi9aJGIyHsjs45OYBqjDBDu97353IHLoUmw,2467
+spikezoo/pipeline/train_pipeline.py,sha256=AseUJJYhZTIA83IFG4F6nRA6UBrMQ3p4gQaDalM8mA8,4060
+spikezoo/utils/__init__.py,sha256=bYLlusAXwLCoY4s6nhVgviax9ioRA9aea8qgRmj2HpI,152
+spikezoo/utils/data_utils.py,sha256=mk1xeyIb7o_E1J7Z6-gtPq-rpKiMTxAWSTcvvPvVku8,2033
+spikezoo/utils/img_utils.py,sha256=0O9z58VzLxQEAuz-GGWCbpeHuHPOCpgBVjCBV9kf6sI,2257
+spikezoo/utils/other_utils.py,sha256=Zy7_UM0AeppKh7u9EFL3hBj7IeQtMwqrSOXDqwBzT74,2539
+spikezoo/utils/spike_utils.py,sha256=CJao2QuQkxEzOCGaf1UfeP0xFsrit5QhIT_uAsLk4PE,2830
+spikezoo-0.1.dist-info/LICENSE.txt,sha256=ukEi8E0PKq1dQGTXHUflg3rppLymwAhr7il9x-0nPgg,1062
+spikezoo-0.1.dist-info/METADATA,sha256=_OkXJ9Yq67P2XDVAJuF74UvSKTn8ga0cMlxoWCrKj0A,1230
+spikezoo-0.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+spikezoo-0.1.dist-info/top_level.txt,sha256=xF2iuOstrACJh43NW4dsTwIdgKfXPXAb_Xzl3M1ricM,9
+spikezoo-0.1.dist-info/RECORD,,

spikezoo-0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

spikezoo-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+spikezoo