langvision 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

langvision/cli/train.py

@@ -9,19 +9,33 @@ import os
 
 
 def parse_args():
-    parser = argparse.ArgumentParser(description='Train or evaluate VisionTransformer with LoRA')
-    parser.add_argument('--dataset', type=str, default='cifar10', choices=['cifar10', 'cifar100'], help='Dataset to use')
-    parser.add_argument('--data_dir', type=str, default='./data', help='Dataset directory')
-    parser.add_argument('--epochs', type=int, default=10)
-    parser.add_argument('--batch_size', type=int, default=64)
-    parser.add_argument('--learning_rate', type=float, default=1e-3)
-    parser.add_argument('--lora_rank', type=int, default=4)
-    parser.add_argument('--lora_alpha', type=float, default=1.0)
-    parser.add_argument('--lora_dropout', type=float, default=0.1)
-    parser.add_argument('--output_dir', type=str, default='./checkpoints')
-    parser.add_argument('--eval', action='store_true', help='Run evaluation only')
-    parser.add_argument('--export', action='store_true', help='Export model for inference')
-    parser.add_argument('--device', type=str, default='cuda' if torch.cuda.is_available() else 'cpu')
+    parser = argparse.ArgumentParser(
+        description='Train or evaluate VisionTransformer with LoRA',
+        epilog='''\nExamples:\n  langvision train --dataset cifar10 --epochs 5\n  langvision train --dataset cifar100 --lora_rank 8 --eval\n''',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    # Data
+    data_group = parser.add_argument_group('Data')
+    data_group.add_argument('--dataset', type=str, default='cifar10', choices=['cifar10', 'cifar100'], help='Dataset to use')
+    data_group.add_argument('--data_dir', type=str, default='./data', help='Dataset directory')
+    # Training
+    train_group = parser.add_argument_group('Training')
+    train_group.add_argument('--epochs', type=int, default=10, help='Number of training epochs')
+    train_group.add_argument('--batch_size', type=int, default=64, help='Batch size for training')
+    train_group.add_argument('--learning_rate', type=float, default=1e-3, help='Learning rate')
+    # LoRA
+    lora_group = parser.add_argument_group('LoRA')
+    lora_group.add_argument('--lora_rank', type=int, default=4, help='LoRA rank (low-rank adaptation)')
+    lora_group.add_argument('--lora_alpha', type=float, default=1.0, help='LoRA alpha scaling')
+    lora_group.add_argument('--lora_dropout', type=float, default=0.1, help='LoRA dropout rate')
+    # Output
+    output_group = parser.add_argument_group('Output')
+    output_group.add_argument('--output_dir', type=str, default='./checkpoints', help='Directory to save checkpoints')
+    # Misc
+    misc_group = parser.add_argument_group('Misc')
+    misc_group.add_argument('--eval', action='store_true', help='Run evaluation only (no training)')
+    misc_group.add_argument('--export', action='store_true', help='Export model for inference')
+    misc_group.add_argument('--device', type=str, default='cuda' if torch.cuda.is_available() else 'cpu', help='Device to use (cuda or cpu)')
     return parser.parse_args()
 
 

langvision/cli/utils.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""
+Utility functions for CLI operations.
+"""
+
+import os
+import sys
+import logging
+from typing import Optional, Dict, Any
+from pathlib import Path
+
+
+def setup_logging_with_progress(log_level: str = 'info', log_file: Optional[str] = None) -> logging.Logger:
+    """Set up logging with progress bar support."""
+    numeric_level = getattr(logging, log_level.upper(), None)
+    if not isinstance(numeric_level, int):
+        numeric_level = logging.INFO
+    
+    # Create logger
+    logger = logging.getLogger('langvision')
+    logger.setLevel(numeric_level)
+    
+    # Clear existing handlers
+    logger.handlers.clear()
+    
+    # Create formatter
+    formatter = logging.Formatter('[%(levelname)s] %(message)s')
+    
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(numeric_level)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    # File handler (if specified)
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(numeric_level)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+    
+    return logger
+
+
+def create_progress_bar(total: int, desc: str = "Processing") -> Any:
+    """Create a progress bar using tqdm."""
+    try:
+        from tqdm import tqdm
+        return tqdm(total=total, desc=desc, unit="it", ncols=100, 
+                   bar_format='{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}]')
+    except ImportError:
+        # Fallback to simple progress indicator
+        return SimpleProgressBar(total, desc)
+
+
+class SimpleProgressBar:
+    """Simple progress bar fallback when tqdm is not available."""
+    
+    def __init__(self, total: int, desc: str = "Processing"):
+        self.total = total
+        self.desc = desc
+        self.current = 0
+        self.width = 50
+        
+    def update(self, n: int = 1):
+        """Update progress."""
+        self.current += n
+        self._display()
+        
+    def _display(self):
+        """Display progress."""
+        if self.total > 0:
+            percent = self.current / self.total
+            filled = int(self.width * percent)
+            bar = '█' * filled + '░' * (self.width - filled)
+            print(f'\r{self.desc}: |{bar}| {self.current}/{self.total} ({percent:.1%})', end='', flush=True)
+            
+    def close(self):
+        """Close progress bar."""
+        print()  # New line
+
+
+def validate_file_path(file_path: str, must_exist: bool = True) -> bool:
+    """Validate file path."""
+    path = Path(file_path)
+    
+    if must_exist and not path.exists():
+        return False
+    
+    if not must_exist:
+        # Check if parent directory exists
+        if not path.parent.exists():
+            try:
+                path.parent.mkdir(parents=True, exist_ok=True)
+            except Exception:
+                return False
+    
+    return True
+
+
+def get_file_size_mb(file_path: str) -> float:
+    """Get file size in MB."""
+    try:
+        size_bytes = os.path.getsize(file_path)
+        return size_bytes / (1024 * 1024)
+    except OSError:
+        return 0.0
+
+
+def format_time(seconds: float) -> str:
+    """Format time in human-readable format."""
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    elif seconds < 3600:
+        minutes = seconds / 60
+        return f"{minutes:.1f}m"
+    else:
+        hours = seconds / 3600
+        return f"{hours:.1f}h"
+
+
+def format_size(size_bytes: int) -> str:
+    """Format size in human-readable format."""
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.1f}{unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.1f}PB"
+
+
+def print_success(message: str):
+    """Print success message with green color."""
+    print(f"\033[1;32m✅ {message}\033[0m")
+
+
+def print_error(message: str):
+    """Print error message with red color."""
+    print(f"\033[1;31m❌ {message}\033[0m")
+
+
+def print_warning(message: str):
+    """Print warning message with yellow color."""
+    print(f"\033[1;33m⚠️ {message}\033[0m")
+
+
+def print_info(message: str):
+    """Print info message with blue color."""
+    print(f"\033[1;34mℹ️ {message}\033[0m")
+
+
+def print_step(step: int, total: int, message: str):
+    """Print step message with progress indicator."""
+    print(f"\033[1;36m[STEP {step}/{total}]\033[0m {message}")
+
+
+def check_dependencies() -> Dict[str, bool]:
+    """Check if required dependencies are available."""
+    dependencies = {
+        'torch': False,
+        'torchvision': False,
+        'numpy': False,
+        'tqdm': False,
+        'pyyaml': False,
+        'matplotlib': False,
+        'pillow': False,
+    }
+    
+    for dep in dependencies:
+        try:
+            __import__(dep)
+            dependencies[dep] = True
+        except ImportError:
+            dependencies[dep] = False
+    
+    return dependencies
+
+
+def print_dependency_status():
+    """Print dependency status."""
+    deps = check_dependencies()
+    
+    print("\n📦 Dependency Status:")
+    print("=" * 30)
+    
+    for dep, available in deps.items():
+        status = "✅" if available else "❌"
+        print(f"{status} {dep}")
+    
+    missing = [dep for dep, available in deps.items() if not available]
+    if missing:
+        print(f"\n⚠️ Missing dependencies: {', '.join(missing)}")
+        print("Install with: pip install " + " ".join(missing))
+
+
+def get_system_info() -> Dict[str, Any]:
+    """Get system information."""
+    import platform
+    import psutil
+    
+    info = {
+        'platform': platform.platform(),
+        'python_version': platform.python_version(),
+        'cpu_count': psutil.cpu_count(),
+        'memory_gb': round(psutil.virtual_memory().total / (1024**3), 1),
+    }
+    
+    # Check for CUDA
+    try:
+        import torch
+        info['cuda_available'] = torch.cuda.is_available()
+        if info['cuda_available']:
+            info['cuda_version'] = torch.version.cuda
+            info['gpu_count'] = torch.cuda.device_count()
+            info['gpu_name'] = torch.cuda.get_device_name(0) if torch.cuda.device_count() > 0 else "Unknown"
+    except ImportError:
+        info['cuda_available'] = False
+    
+    return info
+
+
+def print_system_info():
+    """Print system information."""
+    info = get_system_info()
+    
+    print("\n🖥️ System Information:")
+    print("=" * 30)
+    print(f"Platform: {info['platform']}")
+    print(f"Python: {info['python_version']}")
+    print(f"CPU Cores: {info['cpu_count']}")
+    print(f"Memory: {info['memory_gb']} GB")
+    
+    if info['cuda_available']:
+        print(f"CUDA: {info['cuda_version']}")
+        print(f"GPU: {info['gpu_name']} ({info['gpu_count']} device(s))")
+    else:
+        print("CUDA: Not available")
+
+
+def create_output_directory(output_dir: str) -> bool:
+    """Create output directory if it doesn't exist."""
+    try:
+        Path(output_dir).mkdir(parents=True, exist_ok=True)
+        return True
+    except Exception as e:
+        print_error(f"Failed to create output directory '{output_dir}': {e}")
+        return False
+
+
+def save_results(results: Dict[str, Any], output_file: str) -> bool:
+    """Save results to file."""
+    try:
+        import json
+        with open(output_file, 'w') as f:
+            json.dump(results, f, indent=2)
+        return True
+    except Exception as e:
+        print_error(f"Failed to save results to '{output_file}': {e}")
+        return False

langvision/components/attention.py

@@ -1,6 +1,9 @@
 import torch
 import torch.nn as nn
-from langchain.models.lora import LoRALinear
+import torch.nn.functional as F
+from typing import Optional, Tuple
+import math
+from ..models.lora import LoRALinear, LoRAConfig
 
 class Attention(nn.Module):
     def __init__(self, dim, num_heads=8, lora_config=None):

langvision/concepts/__init__.py

@@ -0,0 +1,9 @@
+from .rlhf import RLHF
+from .cot import CoT
+from .ccot import CCoT
+from .grpo import GRPO
+from .rlvr import RLVR
+from .dpo import DPO
+from .ppo import PPO
+from .lime import LIME
+from .shap import SHAP 

langvision/concepts/ccot.py

@@ -0,0 +1,30 @@
+"""
+CCoT (Contrastive Chain-of-Thought)
+----------------------------------
+Extends CoT by using contrastive learning to distinguish between correct and incorrect reasoning chains.
+
+Example usage:
+    >>> from langvision.concepts.ccot import CCoT
+    >>> class MyCCoT(CCoT):
+    ...     def contrastive_train(self, positive_chains, negative_chains):
+    ...         return super().contrastive_train(positive_chains, negative_chains)
+    >>> ccot = MyCCoT()
+    >>> pos = [['Step 1: Think', 'Step 2: Solve']]
+    >>> neg = [['Step 1: Guess', 'Step 2: Wrong']]
+    >>> ccot.contrastive_train(pos, neg)
+"""
+from abc import ABC, abstractmethod
+from typing import Any, List
+
+class CCoT(ABC):
+    """
+    Abstract base class for Contrastive Chain-of-Thought (CCoT).
+    """
+    @abstractmethod
+    def contrastive_train(self, positive_chains: List[Any], negative_chains: List[Any]) -> None:
+        """
+        Train using positive and negative reasoning chains.
+        """
+        # Simple example: print contrastive pairs (toy logic)
+        for pos, neg in zip(positive_chains, negative_chains):
+            print(f"Positive: {pos} | Negative: {neg}") 

langvision/concepts/cot.py

@@ -0,0 +1,29 @@
+"""
+CoT (Chain-of-Thought)
+----------------------
+A prompting or training method that encourages models to reason step-by-step, improving performance on complex tasks.
+
+Example usage:
+    >>> from langvision.concepts.cot import CoT
+    >>> class MyCoT(CoT):
+    ...     def generate_chain(self, prompt: str) -> list:
+    ...         return super().generate_chain(prompt)
+    >>> cot = MyCoT()
+    >>> chain = cot.generate_chain('What is 2 + 2?')
+    >>> print(chain)
+"""
+from abc import ABC, abstractmethod
+from typing import Any, List
+
+class CoT(ABC):
+    """
+    Abstract base class for Chain-of-Thought (CoT).
+    """
+    @abstractmethod
+    def generate_chain(self, prompt: str) -> List[Any]:
+        """
+        Generate a chain of thought for a given prompt.
+        """
+        # Simple example: split prompt into steps (toy logic)
+        steps = [f"Step {i+1}: {word}" for i, word in enumerate(prompt.split())]
+        return steps 

langvision/concepts/dpo.py

@@ -0,0 +1,37 @@
+"""
+DPO (Direct Preference Optimization)
+-----------------------------------
+An RL method that directly optimizes model outputs based on preference data, often used in LLM fine-tuning.
+
+Example usage:
+    >>> from langvision.concepts.dpo import DPO
+    >>> import torch
+    >>> class MyDPO(DPO):
+    ...     def optimize_with_preferences(self, model, preferences, optimizer):
+    ...         super().optimize_with_preferences(model, preferences, optimizer)
+    >>> model = torch.nn.Linear(2, 1)
+    >>> preferences = [(torch.tensor([1.0, 2.0]), 1.0), (torch.tensor([2.0, 3.0]), -1.0)]
+    >>> optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
+    >>> dpo = MyDPO()
+    >>> dpo.optimize_with_preferences(model, preferences, optimizer)
+"""
+from abc import ABC, abstractmethod
+from typing import Any, List
+import torch
+
+class DPO(ABC):
+    """
+    Abstract base class for Direct Preference Optimization (DPO).
+    """
+    @abstractmethod
+    def optimize_with_preferences(self, model: torch.nn.Module, preferences: List[Any], optimizer: torch.optim.Optimizer) -> None:
+        """
+        Optimize the model using preference data.
+        """
+        for x, pref in preferences:
+            optimizer.zero_grad()
+            output = model(x)
+            # Simple preference loss: maximize output if preferred, minimize if not
+            loss = -pref * output.sum()
+            loss.backward()
+            optimizer.step() 

langvision/concepts/grpo.py

@@ -0,0 +1,25 @@
+"""
+GRPO (Generalized Reinforcement Policy Optimization)
+---------------------------------------------------
+A family of algorithms for optimizing policies in reinforcement learning, generalizing methods like PPO and DPO.
+
+Example usage:
+    >>> from langvision.concepts.grpo import GRPO
+    >>> class MyGRPO(GRPO):
+    ...     def optimize(self, policy: Any, rewards: list) -> None:
+    ...         # Implement GRPO optimization
+    ...         pass
+"""
+from abc import ABC, abstractmethod
+from typing import Any, List
+
+class GRPO(ABC):
+    """
+    Abstract base class for Generalized Reinforcement Policy Optimization (GRPO).
+    """
+    @abstractmethod
+    def optimize(self, policy: Any, rewards: List[Any]) -> None:
+        """
+        Optimize the policy using provided rewards.
+        """
+        pass 

langvision/concepts/lime.py

@@ -0,0 +1,37 @@
+"""
+LIME (Local Interpretable Model-agnostic Explanations)
+-----------------------------------------------------
+A technique for explaining model predictions by approximating them locally with interpretable models.
+
+Example usage:
+    >>> from langvision.concepts.lime import LIME
+    >>> import torch
+    >>> class MyLIME(LIME):
+    ...     def explain(self, model, input_data):
+    ...         return super().explain(model, input_data)
+    >>> model = torch.nn.Linear(2, 1)
+    >>> lime = MyLIME()
+    >>> explanation = lime.explain(model, [[0.5, 1.0], [1.0, 2.0]])
+    >>> print(explanation)
+"""
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+class LIME(ABC):
+    """
+    Abstract base class for Local Interpretable Model-agnostic Explanations (LIME).
+    """
+    @abstractmethod
+    def explain(self, model: Any, input_data: Any) -> Dict[str, Any]:
+        """
+        Generate a local explanation for the model's prediction on input_data using lime if available.
+        """
+        try:
+            from lime.lime_tabular import LimeTabularExplainer
+        except ImportError:
+            raise ImportError("Please install the 'lime' package to use LIME explanations.")
+        import numpy as np
+        X = np.array(input_data)
+        explainer = LimeTabularExplainer(X, mode="regression")
+        explanation = explainer.explain_instance(X[0], lambda x: model(torch.tensor(x, dtype=torch.float32)).detach().numpy())
+        return {"explanation": explanation.as_list()} 

langvision/concepts/ppo.py

@@ -0,0 +1,47 @@
+"""
+PPO (Proximal Policy Optimization)
+---------------------------------
+A popular RL algorithm that balances exploration and exploitation by limiting policy updates to stay within a trust region.
+
+Example usage:
+    >>> import torch
+    >>> from langvision.concepts.ppo import PPO
+    >>> class MyPPO(PPO):
+    ...     def step(self, policy, old_log_probs, states, actions, rewards, optimizer):
+    ...         super().step(policy, old_log_probs, states, actions, rewards, optimizer)
+    >>> policy = torch.nn.Linear(2, 2)
+    >>> old_log_probs = torch.tensor([0.5, 0.5])
+    >>> states = torch.randn(2, 2)
+    >>> actions = torch.tensor([0, 1])
+    >>> rewards = torch.tensor([1.0, 0.5])
+    >>> optimizer = torch.optim.Adam(policy.parameters(), lr=0.01)
+    >>> ppo = MyPPO()
+    >>> ppo.step(policy, old_log_probs, states, actions, rewards, optimizer)
+"""
+from abc import ABC, abstractmethod
+from typing import Any
+import torch
+
+class PPO(ABC):
+    """
+    Abstract base class for Proximal Policy Optimization (PPO).
+    """
+    @abstractmethod
+    def step(self, policy: torch.nn.Module, old_log_probs: torch.Tensor, states: torch.Tensor, actions: torch.Tensor, rewards: torch.Tensor, optimizer: torch.optim.Optimizer) -> None:
+        """
+        Perform a PPO update step.
+        """
+        # Forward pass
+        logits = policy(states)
+        log_probs = torch.log_softmax(logits, dim=-1)
+        selected_log_probs = log_probs[range(len(actions)), actions]
+        # Calculate ratio
+        ratio = torch.exp(selected_log_probs - old_log_probs)
+        # Calculate surrogate loss
+        advantage = rewards - rewards.mean()
+        surr1 = ratio * advantage
+        surr2 = torch.clamp(ratio, 0.8, 1.2) * advantage
+        loss = -torch.min(surr1, surr2).mean()
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step() 

langvision/concepts/rlhf.py

@@ -0,0 +1,40 @@
+"""
+RLHF (Reinforcement Learning from Human Feedback)
+-------------------------------------------------
+A technique where models are trained using feedback from humans to align outputs with human preferences.
+
+Example usage:
+    >>> import torch
+    >>> from langvision.concepts.rlhf import RLHF
+    >>> class MyRLHF(RLHF):
+    ...     def train(self, model, data, feedback_fn, optimizer):
+    ...         super().train(model, data, feedback_fn, optimizer)
+    >>> model = torch.nn.Linear(2, 1)
+    >>> data = [torch.tensor([1.0, 2.0]), torch.tensor([2.0, 3.0])]
+    >>> def feedback_fn(output): return 1.0 if output.item() > 0 else -1.0
+    >>> optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
+    >>> rlhf = MyRLHF()
+    >>> rlhf.train(model, data, feedback_fn, optimizer)
+"""
+from abc import ABC, abstractmethod
+from typing import Any, Callable, List
+import torch
+
+class RLHF(ABC):
+    """
+    Abstract base class for Reinforcement Learning from Human Feedback (RLHF).
+    """
+    @abstractmethod
+    def train(self, model: torch.nn.Module, data: List[Any], feedback_fn: Callable[[Any], float], optimizer: torch.optim.Optimizer) -> None:
+        """
+        Train the model using data and a feedback function that simulates human feedback.
+        """
+        for x in data:
+            optimizer.zero_grad()
+            output = model(x)
+            # Synthetic feedback as reward
+            reward = feedback_fn(output)
+            # Simple loss: negative reward (maximize reward)
+            loss = -reward * output.sum()
+            loss.backward()
+            optimizer.step() 

langvision/concepts/rlvr.py

@@ -0,0 +1,25 @@
+"""
+RLVR (Reinforcement Learning with Value Ranking)
+-----------------------------------------------
+A method that uses value-based ranking to guide policy optimization in RL settings.
+
+Example usage:
+    >>> from langvision.concepts.rlvr import RLVR
+    >>> class MyRLVR(RLVR):
+    ...     def rank_and_update(self, values: list) -> None:
+    ...         # Implement value ranking and update
+    ...         pass
+"""
+from abc import ABC, abstractmethod
+from typing import Any, List
+
+class RLVR(ABC):
+    """
+    Abstract base class for Reinforcement Learning with Value Ranking (RLVR).
+    """
+    @abstractmethod
+    def rank_and_update(self, values: List[Any]) -> None:
+        """
+        Rank values and update the policy accordingly.
+        """
+        pass 

langvision/concepts/shap.py

@@ -0,0 +1,37 @@
+"""
+SHAP (SHapley Additive exPlanations)
+------------------------------------
+A unified approach to interpreting model predictions using Shapley values from cooperative game theory.
+
+Example usage:
+    >>> from langvision.concepts.shap import SHAP
+    >>> import torch
+    >>> class MySHAP(SHAP):
+    ...     def explain(self, model, input_data):
+    ...         return super().explain(model, input_data)
+    >>> model = torch.nn.Linear(2, 1)
+    >>> shap = MySHAP()
+    >>> explanation = shap.explain(model, [[0.5, 1.0], [1.0, 2.0]])
+    >>> print(explanation)
+"""
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+class SHAP(ABC):
+    """
+    Abstract base class for SHapley Additive exPlanations (SHAP).
+    """
+    @abstractmethod
+    def explain(self, model: Any, input_data: Any) -> Dict[str, Any]:
+        """
+        Generate SHAP values for the model's prediction on input_data using shap if available.
+        """
+        try:
+            import shap
+        except ImportError:
+            raise ImportError("Please install the 'shap' package to use SHAP explanations.")
+        import numpy as np
+        X = np.array(input_data)
+        explainer = shap.Explainer(model)
+        shap_values = explainer(X)
+        return {"shap_values": shap_values.values.tolist()}