ToTf 0.2.4__tar.gz → 0.2.6__tar.gz

{totf-0.2.4 → totf-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ToTf
-Version: 0.2.4
+Version: 0.2.6
 Summary: A Cross-Library Compatible Library for PyTorch and TensorFlow that provides advanced features for ease of use
 Home-page: https://github.com/Akshay-Ramesh-VITC/ToTf
 Author: Akshay, Shyamanth Reddy
@@ -124,6 +124,21 @@ Framework-agnostic "missing" functions that save time and improve code quality:
 - **`LRFinder`** - Full-featured LR range test class with plotting
 - **Use case**: Automatically discover the best learning rate before training (fast.ai style), avoid manual tuning
 
+#### Cross-Framework Reproducibility
+- **`seed_everything(seed=42, deterministic=False, benchmark=False, verbose=False)`** - Seeds Python, NumPy, PyTorch (CPU & CUDA), and TensorFlow in a single call. Optionally sets deterministic algorithms and cuBLAS workspace config.
+- **Use case**: Guaranteed reproducible experiments and benchmarks across backends without repeating 10 lines of boilerplate.
+
+#### Tensor Health & Diagnostics
+- **`inspect_tensor(tensor, name=None, print_info=True, quantiles=True)`** - One-line diagnostic inspector for PyTorch, TensorFlow, or NumPy tensors.
+- **Information provided**: Shape, dtype, device, memory MB, element count, NaN/Inf detection, zero sparsity %, min, max, mean, std, and quantiles (p25, p50, p75).
+- **Use case**: Rapid sanity-checking and debugging of activations, embeddings, and gradients.
+
+#### Transfer Learning & Fine-Tuning
+- **`freeze_layers(model, up_to=None, layer_names=None, layer_types=None, regex=None)`** - Freeze model parameters/layers (supports both `torch.nn.Module` and `tf.keras.Model`).
+- **`unfreeze_layers(model, last_n=None, layer_names=None, layer_types=None, regex=None)`** - Selectively unfreeze layers (e.g., `last_n=1` for classification heads).
+- **`freeze_batchnorm(model, freeze_eval=True)`** - Lock BatchNorm affine parameters and freeze running statistics (eval mode) during fine-tuning.
+- **Use case**: Effortless backbone freezing and transfer learning across both frameworks.
+
 ### 📊 ModelView (PyTorch & TensorFlow)
 Publication-quality neural network architecture diagrams for both frameworks:
 - **PyTorch support** - Wraps torchview for comprehensive PyTorch model visualization

{totf-0.2.4 → totf-0.2.6}/README.md

@@ -52,6 +52,21 @@ Framework-agnostic "missing" functions that save time and improve code quality:
 - **`LRFinder`** - Full-featured LR range test class with plotting
 - **Use case**: Automatically discover the best learning rate before training (fast.ai style), avoid manual tuning
 
+#### Cross-Framework Reproducibility
+- **`seed_everything(seed=42, deterministic=False, benchmark=False, verbose=False)`** - Seeds Python, NumPy, PyTorch (CPU & CUDA), and TensorFlow in a single call. Optionally sets deterministic algorithms and cuBLAS workspace config.
+- **Use case**: Guaranteed reproducible experiments and benchmarks across backends without repeating 10 lines of boilerplate.
+
+#### Tensor Health & Diagnostics
+- **`inspect_tensor(tensor, name=None, print_info=True, quantiles=True)`** - One-line diagnostic inspector for PyTorch, TensorFlow, or NumPy tensors.
+- **Information provided**: Shape, dtype, device, memory MB, element count, NaN/Inf detection, zero sparsity %, min, max, mean, std, and quantiles (p25, p50, p75).
+- **Use case**: Rapid sanity-checking and debugging of activations, embeddings, and gradients.
+
+#### Transfer Learning & Fine-Tuning
+- **`freeze_layers(model, up_to=None, layer_names=None, layer_types=None, regex=None)`** - Freeze model parameters/layers (supports both `torch.nn.Module` and `tf.keras.Model`).
+- **`unfreeze_layers(model, last_n=None, layer_names=None, layer_types=None, regex=None)`** - Selectively unfreeze layers (e.g., `last_n=1` for classification heads).
+- **`freeze_batchnorm(model, freeze_eval=True)`** - Lock BatchNorm affine parameters and freeze running statistics (eval mode) during fine-tuning.
+- **Use case**: Effortless backbone freezing and transfer learning across both frameworks.
+
 ### 📊 ModelView (PyTorch & TensorFlow)
 Publication-quality neural network architecture diagrams for both frameworks:
 - **PyTorch support** - Wraps torchview for comprehensive PyTorch model visualization

totf-0.2.6/ToTf/__init__.py

@@ -0,0 +1,35 @@
+"""
+ToTf - A Cross-Library Compatible Library for PyTorch and TensorFlow
+Provides additional features for ease of use not directly available in Torch or TF
+"""
+
+from .backend import get_backend, _BACKEND
+from .backend_manager import SmartSummary, TrainingMonitor, ModelView, draw_graph, get_component
+from .backend_manager import toONNX, fromONNX
+from .backend_manager import (
+    seed_everything,
+    inspect_tensor,
+    freeze_layers,
+    unfreeze_layers,
+    freeze_batchnorm,
+)
+
+__version__ = "0.2.6"
+__author__ = "Akshay"
+__all__ = [
+    "get_backend",
+    "TrainingMonitor",
+    "SmartSummary",
+    "ModelView",
+    "draw_graph",
+    "get_component",
+    "toONNX",
+    "fromONNX",
+    "seed_everything",
+    "inspect_tensor",
+    "freeze_layers",
+    "unfreeze_layers",
+    "freeze_batchnorm",
+]
+
+# Use backend_manager factories for dynamic dispatch to framework implementations

totf-0.2.6/ToTf/backend.py

@@ -0,0 +1,14 @@
+import importlib.util
+
+_BACKEND = None
+
+if importlib.util.find_spec("torch"):
+    _BACKEND = "torch"
+elif importlib.util.find_spec("tensorflow"):
+    _BACKEND = "tensorflow"
+else:
+    raise ImportError("Neither PyTorch nor TensorFlow is installed. Please install one of them.")
+
+def get_backend():
+    """Returns the detected backend: 'torch' or 'tensorflow'"""
+    return _BACKEND

totf-0.2.6/ToTf/backend_manager.py

@@ -0,0 +1,301 @@
+"""
+Backend Manager / Dispatcher
+
+Provides a unified API that dynamically routes calls to the appropriate
+framework implementation (PyTorch or TensorFlow) based on the provided
+model/tensor types or the detected default backend.
+
+Usage:
+    from ToTf import SmartSummary
+    ss = SmartSummary(model_or_args...)
+
+This file avoids heavy imports at module import time and only imports
+framework modules lazily when needed.
+"""
+from typing import Any, Optional, Callable, Dict
+import importlib
+import inspect
+
+from . import backend as _backend_pkg
+
+
+def _import_pytorch_module(name: str):
+    try:
+        return importlib.import_module(f"ToTf.pytorch.{name}")
+    except Exception:
+        return None
+
+
+def _import_tensorflow_module(name: str):
+    try:
+        return importlib.import_module(f"ToTf.tenf.{name}")
+    except Exception:
+        return None
+
+
+def _is_torch_tensor(obj: Any) -> bool:
+    try:
+        import torch
+        return isinstance(obj, torch.Tensor) or isinstance(obj, torch.nn.Module)
+    except Exception:
+        return False
+
+
+def _is_tf_tensor(obj: Any) -> bool:
+    try:
+        import tensorflow as tf
+        return isinstance(obj, (tf.Tensor, tf.Variable, tf.keras.Model, tf.keras.layers.Layer))
+    except Exception:
+        return False
+
+
+def _choose_backend_from_obj(obj: Any) -> Optional[str]:
+    if obj is None:
+        return None
+    if _is_torch_tensor(obj):
+        return "torch"
+    if _is_tf_tensor(obj):
+        return "tensorflow"
+    return None
+
+
+def get_default_backend() -> str:
+    return _backend_pkg.get_backend()
+
+
+def _load_backend_impl(backend_name: str, component: str):
+    if backend_name == "torch":
+        mod = _import_pytorch_module(component)
+        return mod
+    elif backend_name == "tensorflow":
+        mod = _import_tensorflow_module(component)
+        return mod
+    return None
+
+
+def _select_backend_for_args(*args, **kwargs) -> str:
+    # Try to pick a backend from any args/kwargs by checking types
+    for a in list(args) + list(kwargs.values()):
+        b = _choose_backend_from_obj(a)
+        if b:
+            return b
+    # fallback to detected default
+    return get_default_backend()
+
+
+def SmartSummary(*args, **kwargs):
+    """Factory that returns a SmartSummary instance from the appropriate backend.
+
+    Selection order:
+    - If first positional arg is a model object (torch.nn.Module or tf.keras.Model)
+      we pick the backend accordingly.
+    - Otherwise we inspect all args/kwargs for recognizable types (tensors or models).
+    - Fallback to the globally detected backend.
+    """
+    backend_name = None
+    if args:
+        backend_name = _choose_backend_from_obj(args[0])
+    if backend_name is None:
+        backend_name = _select_backend_for_args(*args, **kwargs)
+
+    impl_mod = _load_backend_impl(backend_name, "smartsummary")
+    if impl_mod is None:
+        raise ImportError(f"SmartSummary backend '{backend_name}' not available")
+
+    # The implementation exposes SmartSummary class
+    SmartSummaryCls = getattr(impl_mod, "SmartSummary", None)
+    if SmartSummaryCls is None:
+        raise ImportError(f"SmartSummary class not found in backend module {impl_mod}")
+
+    return SmartSummaryCls(*args, **kwargs)
+
+
+def TrainingMonitor(*args, **kwargs):
+    backend_name = _select_backend_for_args(*args, **kwargs)
+    impl_mod = _load_backend_impl(backend_name, "trainingmonitor")
+    if impl_mod is None:
+        raise ImportError(f"TrainingMonitor backend '{backend_name}' not available")
+    TM = getattr(impl_mod, "TrainingMonitor", None)
+    if TM is None:
+        raise ImportError(f"TrainingMonitor class not found in backend module {impl_mod}")
+    return TM(*args, **kwargs)
+
+
+def ModelView(*args, **kwargs):
+    backend_name = _select_backend_for_args(*args, **kwargs)
+    impl_mod = _load_backend_impl(backend_name, "modelview")
+    if impl_mod is None:
+        raise ImportError(f"ModelView backend '{backend_name}' not available")
+    MV = getattr(impl_mod, "ModelView", None)
+    if MV is None:
+        raise ImportError(f"ModelView class not found in backend module {impl_mod}")
+    return MV(*args, **kwargs)
+
+
+def draw_graph(*args, **kwargs):
+    """Dispatch to the backend-specific convenience draw_graph function.
+
+    This will load the backend's `modelview` component and call its
+    `draw_graph` function. Selection of backend follows the same rules as
+    other factories (inspect args for model/tensor types, then fallback to
+    detected default).
+    """
+    backend_name = _select_backend_for_args(*args, **kwargs)
+    impl_mod = _load_backend_impl(backend_name, "modelview")
+    if impl_mod is None:
+        raise ImportError(f"draw_graph backend '{backend_name}' not available")
+    dg = getattr(impl_mod, "draw_graph", None)
+    if dg is None:
+        raise ImportError(f"draw_graph function not found in backend module {impl_mod}")
+    return dg(*args, **kwargs)
+
+
+# Allow users to register custom backend modules (advanced)
+_CUSTOM: Dict[str, Dict[str, Any]] = {}
+
+
+def register_backend(name: str, components: Dict[str, Any]):
+    _CUSTOM[name] = components
+
+
+def get_backend_for_obj(obj: Any) -> str:
+    b = _choose_backend_from_obj(obj)
+    if b:
+        return b
+    return get_default_backend()
+
+
+def get_component(component: str, backend_name: Optional[str] = None):
+    """Return the backend-specific component module.
+
+    Args:
+        component: name of the component module (e.g. 'utils', 'smartsummary')
+        backend_name: 'torch' or 'tensorflow'. If None, uses detected default.
+
+    Returns:
+        Module object or raises ImportError if unavailable.
+    """
+    if backend_name is None:
+        backend_name = get_default_backend()
+
+    mod = _load_backend_impl(backend_name, component)
+    if mod is None:
+        raise ImportError(f"Component '{component}' not available for backend '{backend_name}'")
+    return mod
+
+
+def toONNX(*args, backend_name: Optional[str] = None, **kwargs):
+    """
+    Dispatch to backend-specific toONNX implementation.
+
+    The function will try to infer backend from the first positional argument
+    (model) if available, otherwise use `backend_name` or the default detected backend.
+    """
+    # Try to infer backend from args
+    b = None
+    if args:
+        b = _choose_backend_from_obj(args[0])
+    if b is None:
+        b = backend_name or get_default_backend()
+
+    impl_mod = _load_backend_impl(b, "utils")
+    if impl_mod is None:
+        raise ImportError(f"toONNX utils not available for backend '{b}'")
+
+    fn = getattr(impl_mod, "toONNX", None)
+    if fn is None:
+        raise ImportError(f"toONNX not implemented in backend utils for '{b}'")
+
+    return fn(*args, **kwargs)
+
+
+def fromONNX(onnx_path: str, *args, backend_name: Optional[str] = None, **kwargs):
+    """
+    Dispatch to a backend-agnostic ONNX inference wrapper. This currently uses onnxruntime
+    under the hood from each backend utils module for consistency.
+    """
+    # backend_name is less important here; both backends use onnxruntime wrapper
+    b = backend_name or get_default_backend()
+    impl_mod = _load_backend_impl(b, "utils")
+    if impl_mod is None:
+        raise ImportError(f"fromONNX utils not available for backend '{b}'")
+
+    fn = getattr(impl_mod, "fromONNX", None)
+    if fn is None:
+        raise ImportError(f"fromONNX not implemented in backend utils for '{b}'")
+
+    return fn(onnx_path, *args, **kwargs)
+
+
+def seed_everything(
+    seed: int = 42,
+    deterministic: bool = False,
+    benchmark: bool = False,
+    verbose: bool = False,
+    backend_name: Optional[str] = None,
+) -> int:
+    """
+    Sets seeds across Python, NumPy, PyTorch, and TensorFlow for reproducibility.
+    """
+    b = backend_name or get_default_backend()
+    impl_mod = _load_backend_impl(b, "utils")
+    if impl_mod is not None and hasattr(impl_mod, "seed_everything"):
+        return impl_mod.seed_everything(seed=seed, deterministic=deterministic, benchmark=benchmark, verbose=verbose)
+    # Fallback to direct seeding
+    import os
+    import random
+    import numpy as np
+    random.seed(seed)
+    os.environ["PYTHONHASHSEED"] = str(seed)
+    np.random.seed(seed)
+    return seed
+
+
+def inspect_tensor(
+    tensor: Any,
+    name: Optional[str] = None,
+    print_info: bool = True,
+    quantiles: bool = True,
+    backend_name: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Inspects a tensor (Torch, TF, or NumPy) and returns detailed statistics and health metrics.
+    """
+    b = _choose_backend_from_obj(tensor) or backend_name or get_default_backend()
+    impl_mod = _load_backend_impl(b, "utils")
+    if impl_mod is None or not hasattr(impl_mod, "inspect_tensor"):
+        raise ImportError(f"inspect_tensor utils not available for backend '{b}'")
+    return impl_mod.inspect_tensor(tensor, name=name, print_info=print_info, quantiles=quantiles)
+
+
+def freeze_layers(model: Any, *args, backend_name: Optional[str] = None, **kwargs) -> int:
+    """
+    Freeze layers or parameters in a PyTorch or TensorFlow model for transfer learning.
+    """
+    b = _choose_backend_from_obj(model) or backend_name or get_default_backend()
+    impl_mod = _load_backend_impl(b, "utils")
+    if impl_mod is None or not hasattr(impl_mod, "freeze_layers"):
+        raise ImportError(f"freeze_layers utils not available for backend '{b}'")
+    return impl_mod.freeze_layers(model, *args, **kwargs)
+
+
+def unfreeze_layers(model: Any, *args, backend_name: Optional[str] = None, **kwargs) -> int:
+    """
+    Unfreeze layers or parameters in a PyTorch or TensorFlow model.
+    """
+    b = _choose_backend_from_obj(model) or backend_name or get_default_backend()
+    impl_mod = _load_backend_impl(b, "utils")
+    if impl_mod is None or not hasattr(impl_mod, "unfreeze_layers"):
+        raise ImportError(f"unfreeze_layers utils not available for backend '{b}'")
+    return impl_mod.unfreeze_layers(model, *args, **kwargs)
+
+
+def freeze_batchnorm(model: Any, *args, backend_name: Optional[str] = None, **kwargs) -> int:
+    """
+    Freeze BatchNorm layers in a PyTorch or TensorFlow model.
+    """
+    b = _choose_backend_from_obj(model) or backend_name or get_default_backend()
+    impl_mod = _load_backend_impl(b, "utils")
+    if impl_mod is None or not hasattr(impl_mod, "freeze_batchnorm"):
+        raise ImportError(f"freeze_batchnorm utils not available for backend '{b}'")
+    return impl_mod.freeze_batchnorm(model, *args, **kwargs)

{totf-0.2.4 → totf-0.2.6}/ToTf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ToTf
-Version: 0.2.4
+Version: 0.2.6
 Summary: A Cross-Library Compatible Library for PyTorch and TensorFlow that provides advanced features for ease of use
 Home-page: https://github.com/Akshay-Ramesh-VITC/ToTf
 Author: Akshay, Shyamanth Reddy
@@ -124,6 +124,21 @@ Framework-agnostic "missing" functions that save time and improve code quality:
 - **`LRFinder`** - Full-featured LR range test class with plotting
 - **Use case**: Automatically discover the best learning rate before training (fast.ai style), avoid manual tuning
 
+#### Cross-Framework Reproducibility
+- **`seed_everything(seed=42, deterministic=False, benchmark=False, verbose=False)`** - Seeds Python, NumPy, PyTorch (CPU & CUDA), and TensorFlow in a single call. Optionally sets deterministic algorithms and cuBLAS workspace config.
+- **Use case**: Guaranteed reproducible experiments and benchmarks across backends without repeating 10 lines of boilerplate.
+
+#### Tensor Health & Diagnostics
+- **`inspect_tensor(tensor, name=None, print_info=True, quantiles=True)`** - One-line diagnostic inspector for PyTorch, TensorFlow, or NumPy tensors.
+- **Information provided**: Shape, dtype, device, memory MB, element count, NaN/Inf detection, zero sparsity %, min, max, mean, std, and quantiles (p25, p50, p75).
+- **Use case**: Rapid sanity-checking and debugging of activations, embeddings, and gradients.
+
+#### Transfer Learning & Fine-Tuning
+- **`freeze_layers(model, up_to=None, layer_names=None, layer_types=None, regex=None)`** - Freeze model parameters/layers (supports both `torch.nn.Module` and `tf.keras.Model`).
+- **`unfreeze_layers(model, last_n=None, layer_names=None, layer_types=None, regex=None)`** - Selectively unfreeze layers (e.g., `last_n=1` for classification heads).
+- **`freeze_batchnorm(model, freeze_eval=True)`** - Lock BatchNorm affine parameters and freeze running statistics (eval mode) during fine-tuning.
+- **Use case**: Effortless backbone freezing and transfer learning across both frameworks.
+
 ### 📊 ModelView (PyTorch & TensorFlow)
 Publication-quality neural network architecture diagrams for both frameworks:
 - **PyTorch support** - Wraps torchview for comprehensive PyTorch model visualization

{totf-0.2.4 → totf-0.2.6}/ToTf.egg-info/SOURCES.txt

@@ -2,23 +2,14 @@ LICENSE
 README.md
 pyproject.toml
 setup.py
+ToTf/__init__.py
+ToTf/backend.py
+ToTf/backend_manager.py
 ToTf.egg-info/PKG-INFO
 ToTf.egg-info/SOURCES.txt
 ToTf.egg-info/dependency_links.txt
 ToTf.egg-info/requires.txt
 ToTf.egg-info/top_level.txt
-pytorch/README.md
-pytorch/__init__.py
-pytorch/modelview.py
-pytorch/smartsummary.py
-pytorch/trainingmonitor.py
-pytorch/utils.py
-tenf/README.md
-tenf/__init__.py
-tenf/computation_nodes.py
-tenf/modelview.py
-tenf/smartsummary.py
-tenf/utils.py
 test/test_connection_api.py
 test/test_connections_visual.py
 test/test_integration.py
@@ -27,6 +18,7 @@ test/test_modelview_tf.py
 test/test_monitor.py
 test/test_onnx_pytorch.py
 test/test_onnx_tensorflow.py
+test/test_phase1_utils.py
 test/test_pytorch_modelview_quick.py
 test/test_smartsummary.py
 test/test_smartsummary_features.py

totf-0.2.6/ToTf.egg-info/top_level.txt

@@ -0,0 +1 @@
+ToTf

{totf-0.2.4 → totf-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ToTf"
-version = "0.2.4"
+version = "0.2.6"
 description = "A Cross-Library Compatible Library for PyTorch and TensorFlow that provides advanced features for ease of use"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -110,8 +110,8 @@ Documentation = "https://github.com/Akshay-Ramesh-VITC/ToTf#readme"
 Repository = "https://github.com/Akshay-Ramesh-VITC/ToTf"
 "Bug Tracker" = "https://github.com/Akshay-Ramesh-VITC/ToTf/issues"
 
-[tool.setuptools]
-packages = ["pytorch", "tenf"]
+[tool.setuptools.packages.find]
+include = ["ToTf"]
 
 [tool.setuptools.package-data]
 "*" = ["*.md", "*.json"]

{totf-0.2.4 → totf-0.2.6}/setup.py

@@ -9,7 +9,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="ToTf",
-    version="0.2.4",
+    version="0.2.6",
     author="Akshay",
     author_email="akshay.r2023@vitstudent.ac.in",
     description="A Cross-Library Compatible Library for PyTorch and TensorFlow",