pytorch-kito 0.2.0__py3-none-any.whl

kito/utils/gpu_utils.py

@@ -0,0 +1,94 @@
+import torch
+
+
+def assign_device(device_type: str = "cuda", gpu_id: int = 0) -> torch.device:
+    """
+    Assign device based on preference and availability.
+
+    Args:
+        device_type: Preferred device ("cuda", "mps", or "cpu")
+        gpu_id: GPU ID for CUDA
+
+    Returns:
+        torch.device: Best available device
+
+    Behavior:
+        - "cuda": Use CUDA if available, else CPU (with warning)
+        - "mps": Use MPS if available, else CPU (with warning)
+        - "cpu": Always CPU (no fallback)
+    """
+    valid_devices = {"cuda", "mps", "cpu"}  # already valitated before, this check might be removed
+    device_type_lower = device_type.lower()
+
+    if device_type_lower not in valid_devices:
+        raise ValueError(
+            f"Invalid device_type: '{device_type}'. "
+            f"Must be one of {valid_devices}."
+        )
+
+    if device_type_lower == "cuda":
+        if torch.cuda.is_available():
+            return torch.device(f"cuda:{gpu_id}")
+        else:
+            print("Warning: CUDA requested but not available. Falling back to CPU.")
+            return torch.device("cpu")
+
+    elif device_type_lower == "mps":
+        if torch.backends.mps.is_available():
+            return torch.device("mps")
+        else:
+            print("Warning: MPS requested but not available. Falling back to CPU.")
+            return torch.device("cpu")
+
+    elif device_type_lower == "cpu":
+        return torch.device("cpu")
+
+def get_available_devices() -> dict:
+    """
+    Get information about all available devices.
+
+    Returns:
+        dict: Dictionary with device availability information
+
+    Example:
+        >>> info = get_available_devices()
+        >>> print(info)
+        {
+            'cuda': True,
+            'cuda_count': 2,
+            'mps': False,
+            'cpu': True
+        }
+    """
+    return {
+        'cuda': torch.cuda.is_available(),
+        'cuda_count': torch.cuda.device_count() if torch.cuda.is_available() else 0,
+        'mps': torch.backends.mps.is_available(),
+        'cpu': True  # CPU is always available
+    }
+
+
+def validate_device_type(device_type: str, raise_error: bool = True) -> bool:
+    """
+    Validate device_type string.
+
+    Args:
+        device_type: Device type to validate
+        raise_error: If True, raise ValueError on invalid type
+
+    Returns:
+        bool: True if valid, False otherwise
+
+    Raises:
+        ValueError: If device_type is invalid and raise_error=True
+    """
+    valid_devices = {"cuda", "mps", "cpu"}
+    is_valid = device_type.lower() in valid_devices
+
+    if not is_valid and raise_error:
+        raise ValueError(
+            f"Invalid device_type: '{device_type}'. "
+            f"Must be one of {valid_devices}."
+        )
+
+    return is_valid

kito/utils/loss_utils.py

@@ -0,0 +1,38 @@
+from torch import nn
+
+from kito.utils.ssim_utils import ssim_loss
+
+_torch_loss_dict = {
+    'mean_squared_error': 'MSELoss',
+    'mean_absolute_error': 'L1Loss',
+    'cross_entropy_loss': 'CrossEntropyLoss',
+    'ctc_loss': 'CTCLoss',
+    'negative_log_likelihood_loss': 'NLLLoss',
+    'negative_log_likelihood_poisson_loss': 'PoissonNLLLoss',
+    'negative_log_likelihood_gaussian_loss': 'GaussianNLLLoss',
+    'kullback_leibler_divergence_loss': 'KLDivLoss',
+    'binary_cross_entropy_loss': 'BCELoss',
+    'binary_cross_entropy_logits_loss': 'BCEWithLogitsLoss',
+    'margin_ranking_loss': 'MarginRankingLoss',
+    'hinge_embedding_loss': 'HingeEmbeddingLoss',
+    'multi_label_margin_loss': 'MultiLabelMarginLoss',
+    'huber_loss': 'HuberLoss',
+    'smooth_l1_loss': 'SmoothL1Loss',
+    'soft_margin_loss': 'SoftMarginLoss',
+    'multi_label_soft_margin_loss': 'MultiLabelSoftMarginLoss',
+    'cosine_embedding_loss': 'CosineEmbeddingLoss',
+    'multi_margin_loss': 'MultiMarginLoss',
+    'triplet_margin_loss': 'TripletMarginLoss',
+    'triplet_margin_distance_loss': 'TripletMarginWithDistanceLoss'
+}
+
+
+def get_loss(loss: str):
+    assert loss != ''
+    loss = loss.lower()
+    if loss in _torch_loss_dict:
+        return getattr(nn, _torch_loss_dict[loss])()  # returns the instantiated object
+    if loss == 'ssim_loss':
+        return ssim_loss  # return the signature of the custom loss: /!\ this is not the object
+    raise ValueError(
+        f"Loss '{loss}' not valid. Supported values are: {', '.join(map(repr, _torch_loss_dict.keys()))}")

kito/utils/ssim_utils.py

@@ -0,0 +1,94 @@
+import torch
+import torch.nn.functional as F
+
+
+def gaussian_kernel(window_size: int, sigma: float, device, dtype):
+    """Create a 2D Gaussian kernel (window_size×window_size)."""
+    coords = torch.arange(window_size, device=device, dtype=dtype) - (window_size - 1) / 2.0
+    g = torch.exp(-(coords ** 2) / (2 * sigma ** 2))
+    g = g / g.sum()
+    # outer product to get 2D kernel
+    gauss2d = g.unsqueeze(1) @ g.unsqueeze(0)
+    return gauss2d
+
+
+def ssim_2d_single(img1, img2, window_size=11, sigma=1.5, K1=0.01, K2=0.03, L=1.0):
+    """
+    Compute SSIM over a single 2D windowed image (float range [0, L]).
+    img1, img2: shape (1, 1, H, W)  (batch=1, channel=1)
+    Returns mean SSIM over all pixels in that 2D image.
+    """
+    # Create Gaussian window
+    device, dtype = img1.device, img1.dtype
+    kernel = gaussian_kernel(window_size, sigma, device, dtype)
+    kernel = kernel.unsqueeze(0).unsqueeze(0)  # shape (1,1,win,win)
+
+    # Convolve to get local means
+    mu1 = F.conv2d(img1, kernel, padding=window_size // 2)
+    mu2 = F.conv2d(img2, kernel, padding=window_size // 2)
+
+    mu1_sq = mu1 * mu1
+    mu2_sq = mu2 * mu2
+    mu1_mu2 = mu1 * mu2
+
+    # local variances: E[x^2] - (E[x])^2
+    sigma1_sq = F.conv2d(img1 * img1, kernel, padding=window_size // 2) - mu1_sq
+    sigma2_sq = F.conv2d(img2 * img2, kernel, padding=window_size // 2) - mu2_sq
+    sigma12 = F.conv2d(img1 * img2, kernel, padding=window_size // 2) - mu1_mu2
+
+    sigma1_sq = torch.clamp(sigma1_sq, min=1e-6)
+    sigma2_sq = torch.clamp(sigma2_sq, min=1e-6)
+
+    # SSIM constants
+    C1 = (K1 * L) ** 2
+    C2 = (K2 * L) ** 2
+    C3 = C2 / 2.0
+
+    # Luminance term
+    luminance = (2 * mu1_mu2 + C1) / (mu1_sq + mu2_sq + C1)
+    # Contrast term
+    contrast = (2 * torch.sqrt(sigma1_sq * sigma2_sq) + C2) / (sigma1_sq + sigma2_sq + C2)
+    # Structure term
+    structure = (sigma12 + C3) / (torch.sqrt(sigma1_sq * sigma2_sq) + C3)
+
+    # Full SSIM map
+    ssim_map = luminance * contrast * structure
+    return ssim_map.mean()
+
+
+def batch_time_ssim(pred, target, window_size=11, sigma=1.5):
+    """
+    pred, target: tensors of shape (B, T, H, W, 1), normalized to [0,1].
+    Returns SSIM per (batch, time) as a tensor (B, T), and also a mean per-batch if desired.
+    """
+    B, T, H, W, C = pred.shape
+    assert C == 1, "SSIM code below assumes single channel"
+    ssim_scores = torch.zeros((B, T), device=pred.device, dtype=pred.dtype)
+
+    for b in range(B):
+        for t in range(T):
+            im1 = target[b, t, ..., :].permute(2, 0, 1).unsqueeze(0)  # shape (1,1,H,W)
+            im2 = pred[b, t, ..., :].permute(2, 0, 1).unsqueeze(0)  # shape (1,1,H,W)
+            ssim_scores[b, t] = ssim_2d_single(im1, im2, window_size, sigma)
+    return ssim_scores  # shape (B, T)
+
+
+def minmax_normalize_sample(x):
+    # x: (T, H, W, 1)
+    mn = x.min(dim=0, keepdim=True)[0].min(dim=1, keepdim=True)[0].min(dim=2, keepdim=True)[0]
+    mx = x.max(dim=0, keepdim=True)[0].max(dim=1, keepdim=True)[0].max(dim=2, keepdim=True)[0]
+    denom = (mx - mn).clamp(min=1e-6)
+    return (x - mn) / denom
+
+def ssim_loss(target, predicted):
+    no_disp_mask = (target.sum(dim=tuple(range(1, target.dim()))) == 0)
+    valid_regress_targets = target[~no_disp_mask]
+    valid_regress_outputs = predicted[~no_disp_mask]
+    B = len(valid_regress_targets)
+    pred = torch.stack([minmax_normalize_sample(valid_regress_outputs[b]) for b in range(B)], dim=0)
+    target = torch.stack([minmax_normalize_sample(valid_regress_targets[b]) for b in range(B)], dim=0)
+
+    ssim_bt = batch_time_ssim(pred, target, window_size=11, sigma=1.5)  # shape (B, T)
+    ssim_per_sample = ssim_bt.mean(dim=1)  # average SSIM over time for each batch
+    loss_ssim = (1.0 - ssim_per_sample).mean()
+    return loss_ssim

pytorch_kito-0.2.0.dist-info/METADATA

@@ -0,0 +1,328 @@
+Metadata-Version: 2.4
+Name: pytorch-kito
+Version: 0.2.0
+Summary: Effortless PyTorch training - define your model, Kito handles the rest
+Author-email: Giuseppe Costantino <giuseppe.costantino95@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Giuseppe Costantino
+        
+        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.
+Project-URL: Homepage, https://github.com/gcostantino/kito
+Project-URL: Documentation, https://kito.readthedocs.io
+Project-URL: Repository, https://github.com/gcostantino/kito
+Project-URL: Bug Tracker, https://github.com/gcostantino/kito/issues
+Keywords: pytorch,deep-learning,machine-learning,training,automation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: h5py>=3.0.0
+Requires-Dist: torchsummary>=1.5.1
+Requires-Dist: packaging>=20.0
+Requires-Dist: tensorboard>=2.10.0
+Requires-Dist: pkbar>=0.5
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.10; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Provides-Extra: tensorboard
+Requires-Dist: tensorboard>=2.10.0; extra == "tensorboard"
+Provides-Extra: docs
+Requires-Dist: sphinx>=5.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.0; extra == "docs"
+Provides-Extra: all
+Requires-Dist: tensorboard>=2.10.0; extra == "all"
+Requires-Dist: pytest>=7.0; extra == "all"
+Requires-Dist: pytest-cov>=4.0; extra == "all"
+Requires-Dist: pytest-mock>=3.10; extra == "all"
+Requires-Dist: black>=23.0; extra == "all"
+Requires-Dist: ruff>=0.1.0; extra == "all"
+Requires-Dist: sphinx>=5.0; extra == "all"
+Requires-Dist: sphinx-rtd-theme>=1.0; extra == "all"
+Dynamic: license-file
+
+# Kito
+
+**Effortless PyTorch training - define your model, Kito handles the rest.**
+
+[![Tests](https://github.com/gcostantino/kito/actions/workflows/tests.yml/badge.svg)](https://github.com/gcostantino/kito/actions)
+[![PyPI version](https://img.shields.io/pypi/v/pytorch-kito)](https://pypi.org/project/pytorch-kito/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![Downloads](https://img.shields.io/pypi/dm/pytorch-kito)](https://pypi.org/project/pytorch-kito/)
+
+Kito is a lightweight PyTorch training library that eliminates boilerplate code. Define your model architecture and loss function - Kito automatically handles training loops, optimization, callbacks, distributed training, and more.
+
+## ✨ Key Features
+
+- **Zero Boilerplate** - No training loops, no optimizer setup, no device management
+- **Auto-Everything** - Automatic model building, optimizer binding, and device assignment
+- **Built-in DDP** - Distributed training works out of the box
+- **Smart Callbacks** - TensorBoard, checkpointing, logging, and custom callbacks
+- **Flexible** - Simple for beginners, powerful for experts
+- **Lightweight** - Minimal dependencies, pure PyTorch under the hood
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install pytorch-kito
+```
+
+### Your First Model in 3 Steps
+
+```python
+import torch.nn as nn
+from kito import Engine, KitoModule
+
+# 1. Define your model
+class MyModel(KitoModule):
+    def build_inner_model(self):
+        self.model = nn.Sequential(
+            nn.Linear(784, 128),
+            nn.ReLU(),
+            nn.Linear(128, 10)
+        )
+        self.model_input_size = (784,)
+
+    def bind_optimizer(self):
+        self.optimizer = torch.optim.Adam(
+            self.model.parameters(),
+            lr=self.learning_rate
+        )
+
+# 2. Initialize
+model = MyModel('MyModel', device, config)
+engine = Engine(model, config)
+
+# 3. Train! (That's it - everything else is automatic)
+engine.fit(train_loader, val_loader, max_epochs=10)
+```
+
+## Philosophy
+
+Kito follows a **"define once, train anywhere"** philosophy:
+
+1. **You focus on**: Model architecture and research ideas
+2. **Kito handles**: Training loops, optimization, distributed training, callbacks
+
+Perfect for researchers who want to iterate quickly without rewriting training code.
+
+## Core Concepts
+
+### KitoModule
+
+Your model inherits from `KitoModule` and implements two methods:
+
+```python
+class MyModel(KitoModule):
+    def build_inner_model(self):
+        # Define your architecture
+        self.model = nn.Sequential(...)
+        self.model_input_size = (C, H, W)  # Input shape
+
+    def bind_optimizer(self):
+        # Choose your optimizer
+        self.optimizer = torch.optim.Adam(
+            self.model.parameters(),
+            lr=self.learning_rate
+        )
+```
+
+### Engine
+
+The `Engine` orchestrates everything:
+
+```python
+engine = Engine(module, config)
+
+# Training
+engine.fit(train_loader, val_loader, max_epochs=100)
+
+# Inference
+predictions = engine.predict(test_loader)
+```
+
+### Data Pipeline
+
+Kito provides a clean data pipeline with preprocessing:
+
+```python
+from kito.data import H5Dataset, GenericDataPipeline
+from kito.data.preprocessing import Pipeline, Normalize, ToTensor
+
+# Create dataset
+dataset = H5Dataset('data.h5')
+
+# Add preprocessing
+preprocessing = Pipeline([
+    Normalize(min_val=0.0, max_val=1.0),
+    ToTensor()
+])
+
+# Setup data pipeline
+pipeline = GenericDataPipeline(
+    config=config,
+    dataset=dataset,
+    preprocessing=preprocessing
+)
+pipeline.setup()
+
+# Get dataloaders
+train_loader = pipeline.train_dataloader()
+val_loader = pipeline.val_dataloader()
+```
+
+### Callbacks
+
+Kito includes powerful callbacks for common tasks:
+
+```python
+from kito.callbacks import ModelCheckpoint, EarlyStopping, CSVLogger
+
+callbacks = [
+    ModelCheckpoint('best_model.pt', monitor='val_loss', mode='min'),
+    EarlyStopping(patience=10, monitor='val_loss'),
+    CSVLogger('training.csv')
+]
+
+engine.fit(train_loader, val_loader, callbacks=callbacks)
+```
+
+Or create custom callbacks:
+
+```python
+from kito.callbacks import Callback
+
+class MyCallback(Callback):
+    def on_epoch_end(self, epoch, logs, **kwargs):
+        print(f"Epoch {epoch}: loss={logs['train_loss']:.4f}")
+```
+
+## Advanced Features
+
+### Distributed Training (DDP)
+
+Enable distributed training with one config change:
+
+```python
+config.training.distributed_training = True
+
+# Everything else stays the same!
+engine.fit(train_loader, val_loader, max_epochs=100)
+```
+
+### Custom Training Logic
+
+Override `training_step` for custom behavior:
+
+```python
+class MyModel(KitoModule):
+    def training_step(self, batch, pbar_handler=None):
+        inputs, targets = batch
+
+        # Custom forward pass
+        outputs = self.model(inputs)
+        loss = self.compute_loss((inputs, targets), outputs)
+
+        # Custom backward (e.g., gradient clipping)
+        self.optimizer.zero_grad()
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)
+        self.optimizer.step()
+
+        return {'loss': loss}
+```
+
+### Multiple Datasets
+
+Kito supports HDF5 and in-memory datasets out of the box:
+
+```python
+from kito.data import H5Dataset, MemDataset
+
+# HDF5 dataset (lazy loading)
+dataset = H5Dataset('large_data.h5')
+
+# In-memory dataset (fast)
+dataset = MemDataset(x_train, y_train)
+```
+
+Register custom datasets easily:
+
+```python
+from kito.data.registry import DATASETS
+
+@DATASETS.register('my_custom_dataset')
+class MyDataset(KitoDataset):
+    def _load_sample(self, index):
+        return data, labels
+```
+
+## 📦 Installation Options
+
+```bash
+# Basic installation
+pip install pytorch-kito
+
+# With TensorBoard support
+pip install pytorch-kito[tensorboard]
+
+# Development installation
+pip install pytorch-kito[dev]
+
+# Everything
+pip install pytorch-kito[all]
+```
+
+## 🤝 Contributing
+
+Contributions are very welcome! Please check out our [Contributing Guide](CONTRIBUTING.md).
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+Kito is inspired by PyTorch Lightning and Keras, aiming to bring similar ease-of-use to pure PyTorch workflows for researchers.
+
+## Contact
+
+- **GitHub Issues**: [Report bugs or request features](https://github.com/gcostantino/kito/issues)
+- **GitHub Discussions**: [Ask questions](https://github.com/gcostantino/kito/discussions)
+
+---
+
+**Made with ❤️ for the PyTorch community**

pytorch_kito-0.2.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+kito/__init__.py,sha256=j5He-bAp7SZYkaisFKyxHtByt-5t4x8tZ2uThTwFrTc,938
+kito/engine.py,sha256=bmuDndaWIXy4gOdsTVyvGjQxKiHrZczzlI09ozfBRwI,30617
+kito/module.py,sha256=Zc3doiqXfAIXNdS6ZYQqdudgRO_bXT2VaABVUbkRvVY,13931
+kito/callbacks/__init__.py,sha256=Yt9BBCepsgnGCbwTsrwLkBjqIbDdsCxrbHERBbQ-748,624
+kito/callbacks/callback_base.py,sha256=AW_h-PEHuOJJA7kEcv7eSl_Gq7k8dLgqdNQX4XvUBjs,3661
+kito/callbacks/csv_logger.py,sha256=8vfUt7NO_XyUoqBNIlpC7tGEnAhbRjGJsXwErFdspH0,1850
+kito/callbacks/ddp_aware_callback.py,sha256=nty5N86jE9Ha26FBbUQpaNrZ5i8ex9lPg_l6bgI6IIQ,2124
+kito/callbacks/early_stopping_callback.py,sha256=lqrV_FDy0xFbPAkfq64eQcDS-yWbJpgfKA7e0hqJaGA,1372
+kito/callbacks/modelcheckpoint.py,sha256=_HFrgdz2fjKsUIq_wj6I_eHbbUViVdgJF3Se48FCB9Q,2376
+kito/callbacks/tensorboard_callback_images.py,sha256=Vpx-63wXfHHy5MJbibJQtuqAkOBITtjKmmJZXfjn9Sk,9210
+kito/callbacks/tensorboard_callbacks.py,sha256=xguPSogXX_U1tyOsolryNcazqCdTBHDWun5FoSrl4Tk,3701
+kito/callbacks/txt_logger.py,sha256=dNDMrwEcbC5coUua4R8rJqiIb5xYY7lyIh9maamE48o,1687
+kito/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kito/config/moduleconfig.py,sha256=qY49kA-zFA4OUuE9lCrJh9cGwf6UjuAoI1k04lsNer0,5631
+kito/data/__init__.py,sha256=h9HIKEHtC3CYD3aWsAUh_dcWYiQ6fmiTOcsXhnuhYGE,723
+kito/data/datapipeline.py,sha256=CgYAtjTN_URPjXi1VvS6GY7nLCa5n3ow-F406St78jI,8292
+kito/data/datasets.py,sha256=L3ClAw9rCkCuXavgaEtSUC6mVr-WLVv6DYhOpeOvIUE,4833
+kito/data/preprocessed_dataset.py,sha256=hiLdMvyvjNWpgAylV07bnifAPAhTeN6eOaeBmIePRRA,1733
+kito/data/preprocessing.py,sha256=VawgS0Kci5gvuvPwurWE-Dj3vV2s0s5jsCdz0FuepMQ,8325
+kito/data/registry.py,sha256=rU8qXlGavSVbwJWEG_1_rbh3imiNpYgPuCz8bqY8_VQ,2279
+kito/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kito/strategies/logger_strategy.py,sha256=76mxBKs1ZlYoZ7MHjfujH9driye3Q_w8wW0BqVX15oE,1269
+kito/strategies/progress_bar_strategy.py,sha256=z2GzKnrXyDiCJahhdNTZobS-lTb2YuOoeYVSx5ybUHU,1791
+kito/strategies/readiness_validator.py,sha256=YUV201JsKtaMgKOV93OVpBzGJjbm9sYrb2SsBCnx_jw,2684
+kito/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kito/utils/decorators.py,sha256=p0gWNNL4F0v1zafxI7BDxUVNZugda1Vw8d4lMDIFt_g,1650
+kito/utils/gpu_utils.py,sha256=MLsOWBLmu92E71amanSc95NSJ38448QBFBaajYh1eCM,2747
+kito/utils/loss_utils.py,sha256=u5rWWBJB1e9pGLSSQARHAe5fI9ZOuLzZqu_22VDebKY,1555
+kito/utils/ssim_utils.py,sha256=gBNCWi6X1KzWofQkJXuzJ6qkXx4Ja8faCKGyWSmJj-k,3771
+pytorch_kito-0.2.0.dist-info/licenses/LICENSE,sha256=yeTd9I65vu2Fo9VOKMHVhFt9UlTbRAAGxhR7OO9Dvbs,1075
+pytorch_kito-0.2.0.dist-info/METADATA,sha256=loEohuioKK1FLmMqWnGCGsAzJQv7s-ILdDl8xI8OQcw,9977
+pytorch_kito-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pytorch_kito-0.2.0.dist-info/top_level.txt,sha256=hDmlE0Vyhj0KWg8m24LOrJKBeDOIqL8b6-Pr5kwQRGM,5
+pytorch_kito-0.2.0.dist-info/RECORD,,

pytorch_kito-0.2.0.dist-info/WHEEL

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

pytorch_kito-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Giuseppe Costantino
+
+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.

pytorch_kito-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+kito