ToTf 0.2.3__tar.gz → 0.2.5__tar.gz

{totf-0.2.3 → totf-0.2.5}/PKG-INFO

@@ -1,17 +1,17 @@
 Metadata-Version: 2.4
 Name: ToTf
-Version: 0.2.3
+Version: 0.2.5
 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
 Author-email: akshay.r2023@vitstudent.ac.in
 License: Apache-2.0
-Project-URL: Homepage, https://github.com/yourusername/ToTf
-Project-URL: Documentation, https://github.com/yourusername/ToTf#readme
-Project-URL: Repository, https://github.com/yourusername/ToTf
-Project-URL: Bug Tracker, https://github.com/yourusername/ToTf/issues
+Project-URL: Homepage, https://github.com/Akshay-Ramesh-VITC/ToTf
+Project-URL: Documentation, https://github.com/Akshay-Ramesh-VITC/ToTf#readme
+Project-URL: Repository, https://github.com/Akshay-Ramesh-VITC/ToTf
+Project-URL: Bug Tracker, https://github.com/Akshay-Ramesh-VITC/ToTf/issues
 Keywords: pytorch,tensorflow,deep-learning,neural-networks,model-visualization,training-monitoring,machine-learning
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence

totf-0.2.5/ToTf/__init__.py

@@ -0,0 +1,14 @@
+"""
+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
+
+__version__ = "0.2.5"
+__author__ = "Akshay"
+__all__ = ["get_backend", "TrainingMonitor", "SmartSummary", "ModelView", "draw_graph", "get_component", "toONNX", "fromONNX"]
+
+# Use backend_manager factories for dynamic dispatch to framework implementations

totf-0.2.5/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.5/ToTf/backend_manager.py

@@ -0,0 +1,227 @@
+"""
+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) or isinstance(obj, tf.keras.Model)
+    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)

{totf-0.2.3 → totf-0.2.5}/ToTf.egg-info/PKG-INFO

@@ -1,17 +1,17 @@
 Metadata-Version: 2.4
 Name: ToTf
-Version: 0.2.3
+Version: 0.2.5
 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
 Author-email: akshay.r2023@vitstudent.ac.in
 License: Apache-2.0
-Project-URL: Homepage, https://github.com/yourusername/ToTf
-Project-URL: Documentation, https://github.com/yourusername/ToTf#readme
-Project-URL: Repository, https://github.com/yourusername/ToTf
-Project-URL: Bug Tracker, https://github.com/yourusername/ToTf/issues
+Project-URL: Homepage, https://github.com/Akshay-Ramesh-VITC/ToTf
+Project-URL: Documentation, https://github.com/Akshay-Ramesh-VITC/ToTf#readme
+Project-URL: Repository, https://github.com/Akshay-Ramesh-VITC/ToTf
+Project-URL: Bug Tracker, https://github.com/Akshay-Ramesh-VITC/ToTf/issues
 Keywords: pytorch,tensorflow,deep-learning,neural-networks,model-visualization,training-monitoring,machine-learning
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence

{totf-0.2.3 → totf-0.2.5}/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

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

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

{totf-0.2.3 → totf-0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ToTf"
-version = "0.2.3"
+version = "0.2.5"
 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"
@@ -23,7 +23,7 @@ keywords = [
     "machine-learning"
 ]
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
@@ -105,13 +105,13 @@ test = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/yourusername/ToTf"
-Documentation = "https://github.com/yourusername/ToTf#readme"
-Repository = "https://github.com/yourusername/ToTf"
-"Bug Tracker" = "https://github.com/yourusername/ToTf/issues"
+Homepage = "https://github.com/Akshay-Ramesh-VITC/ToTf"
+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.3 → totf-0.2.5}/setup.py

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

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

@@ -1,2 +0,0 @@
-pytorch
-tenf

totf-0.2.3/pytorch/README.md

@@ -1,200 +0,0 @@
-# PyTorch Module for ToTf
-
-This module contains PyTorch-specific implementations.
-
-## Modules
-
-### TrainingMonitor
-
-A comprehensive training monitor that integrates seamlessly with PyTorch training loops.
-
-### SmartSummary
-
-Advanced model analysis tool that goes beyond basic `model.summary()` with bottleneck detection and gradient tracking.
-
----
-
-## TrainingMonitor
-
-A comprehensive training monitor that integrates seamlessly with PyTorch training loops.
-
-### Features
-- Real-time progress bars with metric display
-- Automatic CSV logging with timestamps
-- Running averages for all metrics
-- RAM and VRAM monitoring
-- Crash-resistant (auto-flush)
-
-### Usage Example
-
-```python
-from ToTf import TrainingMonitor
-
-# Wrap your DataLoader
-epochs = 5
-
-for epoch in range(epochs):
-    monitor = TrainingMonitor(
-        train_loader,
-        desc=f"Epoch {epoch + 1}",
-        log_file=f"train_log_epoch_{epoch + 1}.csv"
-    )
-    
-    # Iterate through batches
-    for batch in monitor:
-        # Your training logic here
-        loss = training_step(batch)
-        
-        # Log metrics
-        monitor.log({
-            'loss': loss.item(),
-            'lr': optimizer.param_groups[0]['lr']
-        })
-```
-
-### CSV Output Format
-
-The log file contains:
-- `timestamp`: Time of logging
-- `step`: Current step number  
-- `<metric_name>`: Your logged metrics (running average)
-- `RAM_pct`: RAM usage percentage
-- `VRAM_gb`: GPU memory usage in GB
-
-### Notes
-
-- The monitor automatically tracks running averages of all metrics
-- Metrics are flushed to disk after each log call for crash safety
-- VRAM is only logged when CUDA is available
-- Compatible with any PyTorch DataLoader or iterable
-
----
-
-## SmartSummary
-
-Advanced model summary with bottleneck detection and gradient analysis.
-
-### Features
-- **Comprehensive Analysis**: Shows layer types, shapes, and parameters
-- **Bottleneck Detection**: Identifies layers that may slow down training
-- **Gradient Tracking**: Monitors gradient variance to find unstable layers
-- **Memory Estimation**: Calculates memory usage per layer
-- **Export Options**: Save to file or export as dictionary
-- **Works with Complex Models**: Handles nested architectures and residual connections
-
-### Usage Example
-
-```python
-from ToTf import SmartSummary
-import torch.nn as nn
-
-# Create your model
-model = YourModel()
-
-# Basic analysis
-summary = SmartSummary(model, input_size=(3, 224, 224))
-summary.show()
-
-# With gradient tracking
-summary = SmartSummary(
-    model, 
-    input_size=(3, 224, 224),
-    track_gradients=True  # Requires backward pass
-)
-summary.show()
-
-# Get bottlenecks programmatically
-bottlenecks = summary.get_bottlenecks(top_n=5)
-for bn in bottlenecks:
-    print(f"Bottleneck: {bn['layer']}")
-    print(f"  Score: {bn['score']:.2f}")
-    print(f"  Reasons: {', '.join(bn['reasons'])}")
-    print(f"  Parameters: {bn['params']:,}")
-
-# Export analysis
-summary.save_to_file("model_analysis.txt")
-data = summary.to_dict()
-```
-
-### Parameters
-
-- `model` (nn.Module): PyTorch model to analyze
-- `input_size` (Tuple, optional): Input tensor shape excluding batch dimension
-  - Example: `(3, 224, 224)` for RGB images
-  - If omitted, only parameter counting is performed
-- `batch_size` (int): Batch size for shape inference (default: 1)
-- `device` (str): Device for analysis - 'cpu' or 'cuda' (default: 'cpu')
-- `track_gradients` (bool): Whether to track gradient statistics (default: False)
-  - Requires a forward and backward pass
-  - Useful for identifying training instabilities
-
-### Methods
-
-- `show(show_bottlenecks=True)`: Display formatted summary table
-- `get_bottlenecks(top_n=5)`: Get list of bottleneck layers
-- `to_dict()`: Export complete analysis as dictionary
-- `save_to_file(filename)`: Save summary to text file
-
-### Bottleneck Detection
-
-SmartSummary identifies bottlenecks based on:
-
-1. **Parameter Count**: Layers with >10% of total parameters
-2. **Gradient Variance**: High variance indicates potential instability
-3. **Output Size**: Large intermediate tensors (>10MB)
-
-Each bottleneck is scored and ranked. Higher scores indicate more critical bottlenecks.
-
-### Output Format
-
-The summary table shows:
-- **Layer (type)**: Layer class name
-- **Output Shape**: Tensor dimensions after this layer
-- **Param #**: Number of parameters in this layer
-- **Trainable**: Whether layer has trainable parameters (✓/✗)
-- **Gradient Stats** (if tracking enabled): Variance, mean, and max
-
-### Comparison with Other Tools
-
-| Feature | SmartSummary | torchsummary | torchinfo | model.summary() |
-|---------|--------------|--------------|-----------|-----------------|
-| Basic layer info | ✓ | ✓ | ✓ | ✓ |
-| Bottleneck detection | ✓ | ✗ | ✗ | ✗ |
-| Gradient tracking | ✓ | ✗ | ✗ | ✗ |
-| Memory estimation | ✓ | ✓ | ✓ | ✗ |
-| Export to file/dict | ✓ | ✗ | ✓ | ✗ |
-| Complex models | ✓ | Limited | ✓ | Limited |
-| PyTorch native | ✓ | ✓ | ✓ | N/A (TF) |
-
-### Advanced Example
-
-```python
-# Compare different architectures
-models = {
-    "ResNet18": resnet18(),
-    "VGG16": vgg16(),
-    "EfficientNet": efficientnet_b0()
-}
-
-for name, model in models.items():
-    print(f"\n{'='*50}")
-    print(f"Analyzing {name}")
-    print(f"{'='*50}")
-    
-    summary = SmartSummary(model, input_size=(3, 224, 224))
-    bottlenecks = summary.get_bottlenecks(top_n=3)
-    
-    print(f"Total parameters: {summary.total_params:,}")
-    print(f"Top bottleneck: {bottlenecks[0]['layer']}")
-    print(f"  Score: {bottlenecks[0]['score']:.2f}")
-```
-
-### Notes
-
-- The monitor automatically tracks running averages of all metrics
-- Metrics are flushed to disk after each log call for crash safety
-- VRAM is only logged when CUDA is available
-- Compatible with any PyTorch DataLoader or iterable
-- For very large models, omit `input_size` to skip forward pass
-- Gradient tracking adds overhead - use during model design phase
-- Works with models containing skip connections, attention mechanisms, etc.

totf-0.2.3/pytorch/__init__.py

@@ -1,28 +0,0 @@
-"""
-PyTorch-specific modules for ToTf
-"""
-
-from .trainingmonitor import TrainingMonitor
-from .smartsummary import SmartSummary
-from .modelview import ModelView, draw_graph
-from .utils import (
-    lazy_flatten,
-    get_flatten_size,
-    loss_ncc,
-    ncc_score,
-    LRFinder,
-    find_lr
-)
-
-__all__ = [
-    "TrainingMonitor",
-    "SmartSummary",
-    "ModelView",
-    "draw_graph",
-    "lazy_flatten",
-    "get_flatten_size",
-    "loss_ncc",
-    "ncc_score",
-    "LRFinder",
-    "find_lr"
-]