torch-device-manager 0.1.0__tar.gz

torch_device_manager-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ali B.M.
+
+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.

torch_device_manager-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+include requirements.txt
+recursive-include examples *.py

torch_device_manager-0.1.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: torch-device-manager
+Version: 0.1.0
+Summary: A PyTorch device manager for automatic hardware detection and memory optimization
+Home-page: https://github.com/yourusername/torch-device-manager
+Author: Ali B.M.
+Author-email: mainabukarali@gmail.com
+Project-URL: Bug Reports, https://github.com/TempCoder82/torch-device-manager/issues
+Project-URL: Source, https://github.com/TempCoder82/torch-device-manager
+Keywords: pytorch,cuda,mps,device,memory,optimization,machine learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.1.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Torch Device Manager
+
+A lightweight PyTorch utility for automatic hardware detection and memory optimization across different devices (CPU, CUDA, MPS).
+
+## Features
+
+- 🔍 **Automatic Device Detection**: Detects the best available hardware (CUDA, Apple Silicon MPS, or CPU)
+- 🧠 **Memory Optimization**: Automatically adjusts batch sizes and gradient accumulation based on available memory
+- ⚡ **Mixed Precision Support**: Optional automatic mixed precision with gradient scaling
+- 📊 **Memory Monitoring**: Real-time memory usage tracking and logging
+- 🛡️ **Fallback Protection**: Graceful fallback to CPU when requested devices aren't available
+
+## Installation
+
+```bash
+pip install torch-device-manager
+```
+
+## Quick Start
+
+```python
+from torch_device_manager import DeviceManager
+import torch
+
+# Initialize device manager (auto-detects best device)
+device_manager = DeviceManager(device="auto", mixed_precision=True)
+
+# Get the torch device
+device = device_manager.get_device()
+
+# Move your model to the optimal device
+model = YourModel().to(device)
+
+# Optimize batch size based on available memory
+optimal_batch_size, gradient_steps = device_manager.optimize_for_memory(
+    model=model, 
+    batch_size=32
+)
+
+print(f"Using device: {device}")
+print(f"Optimized batch size: {optimal_batch_size}")
+print(f"Gradient accumulation steps: {gradient_steps}")
+```
+
+## Usage in Training Scripts
+
+### Basic Integration
+
+```python
+import torch
+import torch.nn as nn
+from torch_device_manager import DeviceManager
+
+def train_model():
+    # Initialize device manager
+    device_manager = DeviceManager(device="auto", mixed_precision=True)
+    device = device_manager.get_device()
+    
+    # Setup model
+    model = YourModel().to(device)
+    optimizer = torch.optim.Adam(model.parameters())
+    
+    # Optimize memory usage
+    batch_size, gradient_steps = device_manager.optimize_for_memory(model, 32)
+    
+    # Training loop
+    for epoch in range(num_epochs):
+        for batch_idx, (data, target) in enumerate(dataloader):
+            data, target = data.to(device), target.to(device)
+            
+            # Use mixed precision if available
+            if device_manager.mixed_precision and device_manager.scaler:
+                with torch.cuda.amp.autocast():
+                    output = model(data)
+                    loss = criterion(output, target)
+                
+                device_manager.scaler.scale(loss).backward()
+                
+                if (batch_idx + 1) % gradient_steps == 0:
+                    device_manager.scaler.step(optimizer)
+                    device_manager.scaler.update()
+                    optimizer.zero_grad()
+            else:
+                output = model(data)
+                loss = criterion(output, target)
+                loss.backward()
+                
+                if (batch_idx + 1) % gradient_steps == 0:
+                    optimizer.step()
+                    optimizer.zero_grad()
+        
+        # Log memory usage
+        device_manager.log_memory_usage()
+```
+
+### Advanced Usage
+
+```python
+from torch_device_manager import DeviceManager
+
+# Force specific device
+device_manager = DeviceManager(device="cuda", mixed_precision=False)
+
+# Check memory info
+memory_info = device_manager.get_memory_info()
+print(f"Available memory: {memory_info}")
+
+# Manual memory optimization
+if memory_info.get("free_gb", 0) < 2.0:
+    print("Low memory detected, reducing batch size")
+    batch_size = 4
+```
+
+## API Reference
+
+### DeviceManager
+
+#### Constructor
+- `device` (str, default="auto"): Device to use ("auto", "cuda", "mps", "cpu")
+- `mixed_precision` (bool, default=True): Enable mixed precision training
+
+#### Methods
+- `get_device()`: Returns torch.device object
+- `get_memory_info()`: Returns memory information dict
+- `log_memory_usage()`: Logs current memory usage
+- `optimize_for_memory(model, batch_size)`: Returns optimized (batch_size, gradient_steps)
+
+## Device Support
+
+- **CUDA**: Full support with memory optimization and mixed precision
+- **Apple Silicon (MPS)**: Basic support with conservative memory settings
+- **CPU**: Fallback support with optimized batch sizes
+
+## Requirements
+
+- Python >= 3.8
+- PyTorch >= 2.1.1
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions are welcome! 

torch_device_manager-0.1.0/README.md

@@ -0,0 +1,145 @@
+# Torch Device Manager
+
+A lightweight PyTorch utility for automatic hardware detection and memory optimization across different devices (CPU, CUDA, MPS).
+
+## Features
+
+- 🔍 **Automatic Device Detection**: Detects the best available hardware (CUDA, Apple Silicon MPS, or CPU)
+- 🧠 **Memory Optimization**: Automatically adjusts batch sizes and gradient accumulation based on available memory
+- ⚡ **Mixed Precision Support**: Optional automatic mixed precision with gradient scaling
+- 📊 **Memory Monitoring**: Real-time memory usage tracking and logging
+- 🛡️ **Fallback Protection**: Graceful fallback to CPU when requested devices aren't available
+
+## Installation
+
+```bash
+pip install torch-device-manager
+```
+
+## Quick Start
+
+```python
+from torch_device_manager import DeviceManager
+import torch
+
+# Initialize device manager (auto-detects best device)
+device_manager = DeviceManager(device="auto", mixed_precision=True)
+
+# Get the torch device
+device = device_manager.get_device()
+
+# Move your model to the optimal device
+model = YourModel().to(device)
+
+# Optimize batch size based on available memory
+optimal_batch_size, gradient_steps = device_manager.optimize_for_memory(
+    model=model, 
+    batch_size=32
+)
+
+print(f"Using device: {device}")
+print(f"Optimized batch size: {optimal_batch_size}")
+print(f"Gradient accumulation steps: {gradient_steps}")
+```
+
+## Usage in Training Scripts
+
+### Basic Integration
+
+```python
+import torch
+import torch.nn as nn
+from torch_device_manager import DeviceManager
+
+def train_model():
+    # Initialize device manager
+    device_manager = DeviceManager(device="auto", mixed_precision=True)
+    device = device_manager.get_device()
+    
+    # Setup model
+    model = YourModel().to(device)
+    optimizer = torch.optim.Adam(model.parameters())
+    
+    # Optimize memory usage
+    batch_size, gradient_steps = device_manager.optimize_for_memory(model, 32)
+    
+    # Training loop
+    for epoch in range(num_epochs):
+        for batch_idx, (data, target) in enumerate(dataloader):
+            data, target = data.to(device), target.to(device)
+            
+            # Use mixed precision if available
+            if device_manager.mixed_precision and device_manager.scaler:
+                with torch.cuda.amp.autocast():
+                    output = model(data)
+                    loss = criterion(output, target)
+                
+                device_manager.scaler.scale(loss).backward()
+                
+                if (batch_idx + 1) % gradient_steps == 0:
+                    device_manager.scaler.step(optimizer)
+                    device_manager.scaler.update()
+                    optimizer.zero_grad()
+            else:
+                output = model(data)
+                loss = criterion(output, target)
+                loss.backward()
+                
+                if (batch_idx + 1) % gradient_steps == 0:
+                    optimizer.step()
+                    optimizer.zero_grad()
+        
+        # Log memory usage
+        device_manager.log_memory_usage()
+```
+
+### Advanced Usage
+
+```python
+from torch_device_manager import DeviceManager
+
+# Force specific device
+device_manager = DeviceManager(device="cuda", mixed_precision=False)
+
+# Check memory info
+memory_info = device_manager.get_memory_info()
+print(f"Available memory: {memory_info}")
+
+# Manual memory optimization
+if memory_info.get("free_gb", 0) < 2.0:
+    print("Low memory detected, reducing batch size")
+    batch_size = 4
+```
+
+## API Reference
+
+### DeviceManager
+
+#### Constructor
+- `device` (str, default="auto"): Device to use ("auto", "cuda", "mps", "cpu")
+- `mixed_precision` (bool, default=True): Enable mixed precision training
+
+#### Methods
+- `get_device()`: Returns torch.device object
+- `get_memory_info()`: Returns memory information dict
+- `log_memory_usage()`: Logs current memory usage
+- `optimize_for_memory(model, batch_size)`: Returns optimized (batch_size, gradient_steps)
+
+## Device Support
+
+- **CUDA**: Full support with memory optimization and mixed precision
+- **Apple Silicon (MPS)**: Basic support with conservative memory settings
+- **CPU**: Fallback support with optimized batch sizes
+
+## Requirements
+
+- Python >= 3.8
+- PyTorch >= 2.1.1
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions are welcome! 

torch_device_manager-0.1.0/examples/training_example.py

@@ -0,0 +1,148 @@
+"""
+Example training script showing how to use torch-device-manager in a real training scenario
+"""
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
+import logging
+from torch_device_manager import DeviceManager
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+
+class SimpleModel(nn.Module):
+    """Simple neural network for demonstration"""
+    def __init__(self, input_size=784, hidden_size=256, num_classes=10):
+        super(SimpleModel, self).__init__()
+        self.fc1 = nn.Linear(input_size, hidden_size)
+        self.relu = nn.ReLU()
+        self.fc2 = nn.Linear(hidden_size, hidden_size)
+        self.fc3 = nn.Linear(hidden_size, num_classes)
+        self.dropout = nn.Dropout(0.2)
+    
+    def forward(self, x):
+        x = x.view(x.size(0), -1)
+        x = self.fc1(x)
+        x = self.relu(x)
+        x = self.dropout(x)
+        x = self.fc2(x)
+        x = self.relu(x)
+        x = self.dropout(x)
+        x = self.fc3(x)
+        return x
+
+def create_dummy_data(num_samples=1000, input_size=784, num_classes=10):
+    """Create dummy data for demonstration"""
+    X = torch.randn(num_samples, input_size)
+    y = torch.randint(0, num_classes, (num_samples,))
+    return TensorDataset(X, y)
+
+def train_with_device_manager():
+    """Training function using DeviceManager"""
+    
+    # Initialize device manager
+    print("Initializing Device Manager...")
+    device_manager = DeviceManager(device="auto", mixed_precision=True)
+    device = device_manager.get_device()
+    
+    # Create model and move to device
+    print("Setting up model...")
+    model = SimpleModel().to(device)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=0.001)
+    
+    # Create dummy dataset
+    print("Creating dataset...")
+    dataset = create_dummy_data()
+    
+    # Optimize batch size for available memory
+    original_batch_size = 64
+    optimized_batch_size, gradient_accumulation_steps = device_manager.optimize_for_memory(
+        model, original_batch_size
+    )
+    
+    dataloader = DataLoader(
+        dataset, 
+        batch_size=optimized_batch_size, 
+        shuffle=True
+    )
+    
+    print(f"Training configuration:")
+    print(f"  - Device: {device}")
+    print(f"  - Original batch size: {original_batch_size}")
+    print(f"  - Optimized batch size: {optimized_batch_size}")
+    print(f"  - Gradient accumulation steps: {gradient_accumulation_steps}")
+    print(f"  - Mixed precision: {device_manager.mixed_precision}")
+    
+    # Training loop
+    num_epochs = 5
+    model.train()
+    
+    for epoch in range(num_epochs):
+        total_loss = 0.0
+        accumulation_count = 0
+        
+        for batch_idx, (data, target) in enumerate(dataloader):
+            data, target = data.to(device), target.to(device)
+            
+            # Use mixed precision if available
+            if device_manager.mixed_precision and device_manager.scaler is not None:
+                with torch.cuda.amp.autocast():
+                    output = model(data)
+                    loss = criterion(output, target) / gradient_accumulation_steps
+                
+                device_manager.scaler.scale(loss).backward()
+                accumulation_count += 1
+                
+                # Update weights after accumulating gradients
+                if accumulation_count >= gradient_accumulation_steps:
+                    device_manager.scaler.step(optimizer)
+                    device_manager.scaler.update()
+                    optimizer.zero_grad()
+                    accumulation_count = 0
+                    
+            else:
+                output = model(data)
+                loss = criterion(output, target) / gradient_accumulation_steps
+                loss.backward()
+                accumulation_count += 1
+                
+                # Update weights after accumulating gradients
+                if accumulation_count >= gradient_accumulation_steps:
+                    optimizer.step()
+                    optimizer.zero_grad()
+                    accumulation_count = 0
+            
+            total_loss += loss.item() * gradient_accumulation_steps
+            
+            # Log progress every 10 batches
+            if batch_idx % 10 == 0:
+                print(f'Epoch {epoch+1}/{num_epochs}, Batch {batch_idx}, '
+                      f'Loss: {loss.item() * gradient_accumulation_steps:.4f}')
+        
+        # Handle any remaining accumulated gradients
+        if accumulation_count > 0:
+            if device_manager.mixed_precision and device_manager.scaler is not None:
+                device_manager.scaler.step(optimizer)
+                device_manager.scaler.update()
+            else:
+                optimizer.step()
+            optimizer.zero_grad()
+        
+        avg_loss = total_loss / len(dataloader)
+        print(f'Epoch {epoch+1}/{num_epochs} completed. Average Loss: {avg_loss:.4f}')
+        
+        # Log memory usage after each epoch
+        device_manager.log_memory_usage()
+    
+    print("Training completed!")
+    
+    # Final memory check
+    print("\nFinal memory state:")
+    memory_info = device_manager.get_memory_info()
+    print(memory_info)
+
+if __name__ == "__main__":
+    train_with_device_manager()

torch_device_manager-0.1.0/requirements.txt

@@ -0,0 +1 @@
+torch>=2.1.1

torch_device_manager-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

torch_device_manager-0.1.0/setup.py

@@ -0,0 +1,39 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="torch-device-manager",
+    version="0.1.0",
+    author="Ali B.M.",
+    author_email="mainabukarali@gmail.com",
+    description="A PyTorch device manager for automatic hardware detection and memory optimization",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+        url="https://github.com/yourusername/torch-device-manager",
+        packages=find_packages(),
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.8",
+    install_requires=[
+        "torch>=2.1.1",
+    ],
+    keywords="pytorch, cuda, mps, device, memory, optimization, machine learning",
+    project_urls={
+        "Bug Reports": "https://github.com/TempCoder82/torch-device-manager/issues",
+        "Source": "https://github.com/TempCoder82/torch-device-manager",
+    },
+)

torch_device_manager-0.1.0/torch_device_manager/__init__.py

@@ -0,0 +1,119 @@
+"""
+Torch Device Manager - Automatic hardware detection and memory optimization for PyTorch
+"""
+
+import logging
+from typing import Tuple
+import torch
+
+__version__ = "0.1.0"
+__author__ = "Ali B.M."
+
+# Set up logging
+logger = logging.getLogger(__name__)
+
+class DeviceManager:
+    """Manage device selection and memory optimization for different hardware"""
+    
+    def __init__(self, device: str = "auto", mixed_precision: bool = True):
+        self.device = self._detect_device(device)
+        self.mixed_precision = mixed_precision
+        self.scaler = None
+        
+        logger.info(f"Device Manager initialized:")
+        logger.info(f"  - Device: {self.device}")
+        logger.info(f"  - Mixed Precision: {self.mixed_precision}")
+        
+        if self.mixed_precision and self.device != "cpu":
+            self.scaler = torch.cuda.amp.GradScaler()
+            logger.info(f"  - Gradient Scaler: Enabled")
+    
+    def _detect_device(self, device: str) -> str:
+        """Detect the best available device"""
+        if device == "auto":
+            if torch.cuda.is_available():
+                device = "cuda"
+                logger.info(f"CUDA detected: {torch.cuda.get_device_name()}")
+                logger.info(f"CUDA memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
+            elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
+                device = "mps"
+                logger.info(f"Apple Silicon MPS detected")
+            else:
+                device = "cpu"
+                logger.info(f"Using CPU")
+        else:
+            if device == "cuda" and not torch.cuda.is_available():
+                logger.warning("CUDA requested but not available, falling back to CPU")
+                device = "cpu"
+            elif device == "mps" and not (hasattr(torch.backends, 'mps') and torch.backends.mps.is_available()):
+                logger.warning("MPS requested but not available, falling back to CPU")
+                device = "cpu"
+        
+        return device
+    
+    def get_device(self):
+        """Get the torch device object"""
+        return torch.device(self.device)
+    
+    def get_memory_info(self):
+        """Get memory information for the current device"""
+        if self.device == "cuda":
+            allocated = torch.cuda.memory_allocated() / 1e9
+            reserved = torch.cuda.memory_reserved() / 1e9
+            total = torch.cuda.get_device_properties(0).total_memory / 1e9
+            return {
+                "allocated_gb": allocated,
+                "reserved_gb": reserved,
+                "total_gb": total,
+                "free_gb": total - reserved
+            }
+        elif self.device == "mps":
+            # MPS doesn't provide detailed memory info like CUDA
+            return {"device": "mps", "info": "Memory info not available for MPS"}
+        else:
+            return {"device": "cpu", "info": "Memory info not available for CPU"}
+    
+    def log_memory_usage(self):
+        """Log current memory usage"""
+        memory_info = self.get_memory_info()
+        if "allocated_gb" in memory_info:
+            logger.info(f"Memory Usage: {memory_info['allocated_gb']:.2f}GB allocated, "
+                       f"{memory_info['free_gb']:.2f}GB free")
+    
+    def optimize_for_memory(self, model, batch_size: int) -> Tuple[int, int]:
+        """Optimize batch size and gradient accumulation for available memory"""
+        
+        if self.device == "cpu":
+            # CPU: Use smaller batches
+            optimized_batch_size = min(batch_size, 8)
+            gradient_steps = max(1, batch_size // optimized_batch_size)
+            logger.info(f"CPU optimization: batch_size={optimized_batch_size}, gradient_steps={gradient_steps}")
+            
+        elif self.device == "mps":
+            # Apple Silicon: Conservative settings
+            optimized_batch_size = min(batch_size, 4)
+            gradient_steps = max(1, batch_size // optimized_batch_size)
+            logger.info(f"MPS optimization: batch_size={optimized_batch_size}, gradient_steps={gradient_steps}")
+            
+        elif self.device == "cuda":
+            # CUDA: Check available memory
+            memory_info = self.get_memory_info()
+            total_memory = memory_info["total_gb"]
+            
+            if total_memory < 8:  # Less than 8GB
+                optimized_batch_size = min(batch_size, 4)
+                gradient_steps = max(1, batch_size // optimized_batch_size)
+                logger.info(f"CUDA <8GB optimization: batch_size={optimized_batch_size}, gradient_steps={gradient_steps}")
+            elif total_memory < 16:  # Less than 16GB
+                optimized_batch_size = min(batch_size, 8)
+                gradient_steps = max(1, batch_size // optimized_batch_size)
+                logger.info(f"CUDA <16GB optimization: batch_size={optimized_batch_size}, gradient_steps={gradient_steps}")
+            else:  # 16GB or more
+                optimized_batch_size = batch_size
+                gradient_steps = 1
+                logger.info(f"CUDA >=16GB: using full batch_size={optimized_batch_size}")
+        
+        return optimized_batch_size, gradient_steps
+
+# Make DeviceManager easily importable
+__all__ = ["DeviceManager"]

torch_device_manager-0.1.0/torch_device_manager.egg-info/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: torch-device-manager
+Version: 0.1.0
+Summary: A PyTorch device manager for automatic hardware detection and memory optimization
+Home-page: https://github.com/yourusername/torch-device-manager
+Author: Ali B.M.
+Author-email: mainabukarali@gmail.com
+Project-URL: Bug Reports, https://github.com/TempCoder82/torch-device-manager/issues
+Project-URL: Source, https://github.com/TempCoder82/torch-device-manager
+Keywords: pytorch,cuda,mps,device,memory,optimization,machine learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.1.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Torch Device Manager
+
+A lightweight PyTorch utility for automatic hardware detection and memory optimization across different devices (CPU, CUDA, MPS).
+
+## Features
+
+- 🔍 **Automatic Device Detection**: Detects the best available hardware (CUDA, Apple Silicon MPS, or CPU)
+- 🧠 **Memory Optimization**: Automatically adjusts batch sizes and gradient accumulation based on available memory
+- ⚡ **Mixed Precision Support**: Optional automatic mixed precision with gradient scaling
+- 📊 **Memory Monitoring**: Real-time memory usage tracking and logging
+- 🛡️ **Fallback Protection**: Graceful fallback to CPU when requested devices aren't available
+
+## Installation
+
+```bash
+pip install torch-device-manager
+```
+
+## Quick Start
+
+```python
+from torch_device_manager import DeviceManager
+import torch
+
+# Initialize device manager (auto-detects best device)
+device_manager = DeviceManager(device="auto", mixed_precision=True)
+
+# Get the torch device
+device = device_manager.get_device()
+
+# Move your model to the optimal device
+model = YourModel().to(device)
+
+# Optimize batch size based on available memory
+optimal_batch_size, gradient_steps = device_manager.optimize_for_memory(
+    model=model, 
+    batch_size=32
+)
+
+print(f"Using device: {device}")
+print(f"Optimized batch size: {optimal_batch_size}")
+print(f"Gradient accumulation steps: {gradient_steps}")
+```
+
+## Usage in Training Scripts
+
+### Basic Integration
+
+```python
+import torch
+import torch.nn as nn
+from torch_device_manager import DeviceManager
+
+def train_model():
+    # Initialize device manager
+    device_manager = DeviceManager(device="auto", mixed_precision=True)
+    device = device_manager.get_device()
+    
+    # Setup model
+    model = YourModel().to(device)
+    optimizer = torch.optim.Adam(model.parameters())
+    
+    # Optimize memory usage
+    batch_size, gradient_steps = device_manager.optimize_for_memory(model, 32)
+    
+    # Training loop
+    for epoch in range(num_epochs):
+        for batch_idx, (data, target) in enumerate(dataloader):
+            data, target = data.to(device), target.to(device)
+            
+            # Use mixed precision if available
+            if device_manager.mixed_precision and device_manager.scaler:
+                with torch.cuda.amp.autocast():
+                    output = model(data)
+                    loss = criterion(output, target)
+                
+                device_manager.scaler.scale(loss).backward()
+                
+                if (batch_idx + 1) % gradient_steps == 0:
+                    device_manager.scaler.step(optimizer)
+                    device_manager.scaler.update()
+                    optimizer.zero_grad()
+            else:
+                output = model(data)
+                loss = criterion(output, target)
+                loss.backward()
+                
+                if (batch_idx + 1) % gradient_steps == 0:
+                    optimizer.step()
+                    optimizer.zero_grad()
+        
+        # Log memory usage
+        device_manager.log_memory_usage()
+```
+
+### Advanced Usage
+
+```python
+from torch_device_manager import DeviceManager
+
+# Force specific device
+device_manager = DeviceManager(device="cuda", mixed_precision=False)
+
+# Check memory info
+memory_info = device_manager.get_memory_info()
+print(f"Available memory: {memory_info}")
+
+# Manual memory optimization
+if memory_info.get("free_gb", 0) < 2.0:
+    print("Low memory detected, reducing batch size")
+    batch_size = 4
+```
+
+## API Reference
+
+### DeviceManager
+
+#### Constructor
+- `device` (str, default="auto"): Device to use ("auto", "cuda", "mps", "cpu")
+- `mixed_precision` (bool, default=True): Enable mixed precision training
+
+#### Methods
+- `get_device()`: Returns torch.device object
+- `get_memory_info()`: Returns memory information dict
+- `log_memory_usage()`: Logs current memory usage
+- `optimize_for_memory(model, batch_size)`: Returns optimized (batch_size, gradient_steps)
+
+## Device Support
+
+- **CUDA**: Full support with memory optimization and mixed precision
+- **Apple Silicon (MPS)**: Basic support with conservative memory settings
+- **CPU**: Fallback support with optimized batch sizes
+
+## Requirements
+
+- Python >= 3.8
+- PyTorch >= 2.1.1
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions are welcome! 

torch_device_manager-0.1.0/torch_device_manager.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+README.md
+requirements.txt
+setup.py
+examples/training_example.py
+tests/__init__.py
+torch_device_manager/__init__.py
+torch_device_manager/py.typed
+torch_device_manager.egg-info/PKG-INFO
+torch_device_manager.egg-info/SOURCES.txt
+torch_device_manager.egg-info/dependency_links.txt
+torch_device_manager.egg-info/requires.txt
+torch_device_manager.egg-info/top_level.txt

torch_device_manager-0.1.0/torch_device_manager.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

torch_device_manager-0.1.0/torch_device_manager.egg-info/requires.txt

@@ -0,0 +1 @@
+torch>=2.1.1

torch_device_manager-0.1.0/torch_device_manager.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+tests
+torch_device_manager