scitex 2.0.0__py2.py3-none-any.whl

scitex/ai/early_stopping.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+# Time-stamp: "2024-09-07 01:09:38 (ywatanabe)"
+
+import os
+
+import scitex
+import numpy as np
+
+
+class EarlyStopping:
+    """
+    Early stops the training if the validation score doesn't improve after a given patience period.
+
+    """
+
+    def __init__(self, patience=7, verbose=False, delta=1e-5, direction="minimize"):
+        """
+        Args:
+            patience (int): How long to wait after last time validation score improved.
+                            Default: 7
+            verbose (bool): If True, prints a message for each validation score improvement.
+                            Default: False
+            delta (float): Minimum change in the monitored quantity to qualify as an improvement.
+                            Default: 0
+        """
+        self.patience = patience
+        self.verbose = verbose
+        self.direction = direction
+
+        self.delta = delta
+
+        # default
+        self.counter = 0
+        self.best_score = np.inf if direction == "minimize" else -np.inf
+        self.best_i_global = None
+        self.models_spaths_dict = {}
+
+    def is_best(self, val_score):
+        is_smaller = val_score < self.best_score - abs(self.delta)
+        is_larger = self.best_score + abs(self.delta) < val_score
+        return is_smaller if self.direction == "minimize" else is_larger
+
+    def __call__(self, current_score, models_spaths_dict, i_global):
+        # The 1st call
+        if self.best_score is None:
+            self.save(current_score, models_spaths_dict, i_global)
+            return False
+
+        # After the 2nd call
+        if self.is_best(current_score):
+            self.save(current_score, models_spaths_dict, i_global)
+            self.counter = 0
+            return False
+
+        else:
+            self.counter += 1
+            if self.verbose:
+                print(
+                    f"\nEarlyStopping counter: {self.counter} out of {self.patience}\n"
+                )
+            if self.counter >= self.patience:
+                if self.verbose:
+                    scitex.gen.print_block("Early-stopped.", c="yellow")
+                return True
+
+    def save(self, current_score, models_spaths_dict, i_global):
+        """Saves model when validation score decrease."""
+
+        if self.verbose:
+            print(
+                f"\nUpdate the best score: ({self.best_score:.6f} --> {current_score:.6f})"
+            )
+
+        self.best_score = current_score
+        self.best_i_global = i_global
+
+        for model, spath in models_spaths_dict.items():
+            scitex.io.save(model.state_dict(), spath)
+
+        self.models_spaths_dict = models_spaths_dict
+
+
+if __name__ == "__main__":
+    pass
+    # # starts the current fold's loop
+    # i_global = 0
+    # lc_logger = scitex.ml.LearningCurveLogger()
+    # early_stopping = utils.EarlyStopping(patience=50, verbose=True)
+    # for i_epoch, epoch in enumerate(tqdm(range(merged_conf["MAX_EPOCHS"]))):
+
+    #     dlf.fill(i_fold, reset_fill_counter=False)
+
+    #     step_str = "Validation"
+    #     for i_batch, batch in enumerate(dlf.dl_val):
+    #         _, loss_diag_val = utils.base_step(
+    #             step_str,
+    #             model,
+    #             mtl,
+    #             batch,
+    #             device,
+    #             i_fold,
+    #             i_epoch,
+    #             i_batch,
+    #             i_global,
+    #             lc_logger,
+    #             no_mtl=args.no_mtl,
+    #             print_batch_interval=False,
+    #         )
+    #     lc_logger.print(step_str)
+
+    #     step_str = "Training"
+    #     for i_batch, batch in enumerate(dlf.dl_tra):
+    #         optimizer.zero_grad()
+    #         loss, _ = utils.base_step(
+    #             step_str,
+    #             model,
+    #             mtl,
+    #             batch,
+    #             device,
+    #             i_fold,
+    #             i_epoch,
+    #             i_batch,
+    #             i_global,
+    #             lc_logger,
+    #             no_mtl=args.no_mtl,
+    #             print_batch_interval=False,
+    #         )
+    #         loss.backward()
+    #         optimizer.step()
+    #         i_global += 1
+    #     lc_logger.print(step_str)
+
+    #     bACC_val = np.array(lc_logger.logged_dict["Validation"]["bACC_diag_plot"])[
+    #         np.array(lc_logger.logged_dict["Validation"]["i_epoch"]) == i_epoch
+    #     ].mean()
+
+    #     model_spath = (
+    #         merged_conf["sdir"]
+    #         + f"checkpoints/model_fold#{i_fold}_epoch#{i_epoch:03d}.pth"
+    #     )
+    #     mtl_spath = model_spath.replace("model_fold", "mtl_fold")
+    #     models_spaths_dict = {model_spath: model, mtl_spath: mtl}
+
+    #     early_stopping(loss_diag_val, models_spaths_dict, i_epoch, i_global)
+    #     # early_stopping(-bACC_val, models_spaths_dict, i_epoch, i_global)
+
+    #     if early_stopping.early_stop:
+    #         print("Early stopping")
+    #         break

scitex/ai/feature_extraction/__init__.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-20 10:53:22 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/feature_extraction/__init__.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/feature_extraction/__init__.py"
+
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-10-22 19:51:47 (ywatanabe)"
+# File: __init__.py
+
+import os as __os
+import importlib as __importlib
+import inspect as __inspect
+import warnings as __warnings
+
+# Get the current directory
+current_dir = __os.path.dirname(__file__)
+
+# Iterate through all Python files in the current directory
+for filename in __os.listdir(current_dir):
+    if filename.endswith(".py") and not filename.startswith("__"):
+        module_name = filename[:-3]  # Remove .py extension
+        try:
+            module = __importlib.import_module(f".{module_name}", package=__name__)
+            
+            # Import only functions and classes from the module
+            for name, obj in __inspect.getmembers(module):
+                if __inspect.isfunction(obj) or __inspect.isclass(obj):
+                    if not name.startswith("_"):
+                        globals()[name] = obj
+        except ImportError as e:
+            # Warn about modules that couldn't be imported due to missing dependencies
+            __warnings.warn(
+                f"Could not import {module_name} from scitex.ai.feature_extraction: {str(e)}. "
+                f"Some functionality may be unavailable. "
+                f"Consider installing missing dependencies if you need this module.",
+                ImportWarning,
+                stacklevel=2
+            )
+
+# Clean up temporary variables
+del __os, __importlib, __inspect, __warnings, current_dir
+if 'filename' in locals():
+    del filename
+if 'module_name' in locals():
+    del module_name
+if 'module' in locals():
+    del module
+if 'name' in locals():
+    del name
+if 'obj' in locals():
+    del obj
+
+# EOF

scitex/ai/feature_extraction/vit.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-27 21:36:51 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/feature_extraction/vit.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/feature_extraction/vit.py"
+
+"""
+Functionality:
+    Extracts features from images using Vision Transformer (ViT) models
+Input:
+    Image arrays of arbitrary dimensions
+Output:
+    Feature vectors (1000-dimensional embeddings)
+Prerequisites:
+    torch, PIL, torchvision
+"""
+
+import os as _os
+from typing import Tuple, Union
+
+import torch
+import torch as _torch
+from pytorch_pretrained_vit import ViT
+from torchvision import transforms as _transforms
+
+# from ...decorators import batch_torch_fn
+
+
+def _setup_device(device: Union[str, None]) -> str:
+    if device is None:
+        device = "cuda" if _torch.cuda.is_available() else "cpu"
+    return device
+
+
+class VitFeatureExtractor:
+    def __init__(
+        self,
+        model_name="B_16",
+        torch_home="./models",
+        device=None,
+    ):
+        self.valid_models = [
+            "B_16",
+            "B_32",
+            "L_16",
+            "L_32",
+            "B_16_imagenet1k",
+            "B_32_imagenet1k",
+            "L_16_imagenet1k",
+            "L_32_imagenet1k",
+        ]
+        self.model_name = model_name
+        self.torch_home = torch_home
+        self.device = _setup_device(device)
+
+        _os.environ["TORCH_HOME"] = torch_home
+        self._validate_inputs()
+        self.model = ViT(model_name, pretrained=True).to(self.device).eval()
+        self.transform = _transforms.Compose(
+            [
+                _transforms.ToPILImage(),
+                _transforms.Resize(self.model.image_size),
+                _transforms.ToTensor(),
+                _transforms.Normalize(0.5, 0.5),
+            ]
+        )
+
+    def _validate_inputs(self):
+        if self.model_name not in self.valid_models:
+            raise ValueError(f"Invalid model name. Choose from: {self.valid_models}")
+        if not _os.path.exists(self.torch_home):
+            raise FileNotFoundError(f"Model directory not found: {self.torch_home}")
+
+    def _preprocess_array(
+        self,
+        arr: _torch.Tensor,
+        dim: Tuple[int, int],
+        channel_dim: Union[int, None],
+    ) -> _torch.Tensor:
+        # print(f"Input array shape: {arr.shape}")
+
+        orig_shape = arr.shape
+        dim = tuple(d if d >= 0 else len(orig_shape) + d for d in dim)
+
+        perm = list(range(len(orig_shape)))
+        for d in sorted(dim):
+            perm.remove(d)
+            perm.append(d)
+        arr = arr.permute(perm)
+
+        # Flatten all dimensions except the last two (spatial dimensions)
+        batch_shape = arr.shape[:-2]
+        spatial_shape = arr.shape[-2:]
+        arr = arr.reshape(-1, *spatial_shape)
+
+        # Process each image
+        transformed = []
+        for img in arr:
+            img = img.unsqueeze(0)
+            img = img.repeat(3, 1, 1)
+            transformed.append(self.transform(img))
+        result = _torch.stack(transformed)
+        return result, batch_shape
+
+    # @batch_method
+    # @torch_method
+    # @batch_torch_fn
+    def extract_features(
+        self,
+        arr,
+        axis=(-2, -1),
+        dim=None,
+        channel_dim=None,
+        batch_size=None,
+        device="cuda",
+    ):
+
+        processed_arr, batch_shape = self._preprocess_array(
+            arr,
+            axis,
+            channel_dim,
+        )
+        # print(f"Processed shape: {processed_arr.shape}")
+
+        processed_arr = processed_arr.to(self.device)
+        with _torch.no_grad():
+            features = self.model(processed_arr).cpu()
+
+        return features.reshape(*batch_shape, -1)
+
+
+if __name__ == "__main__":
+    import scitex
+
+    extractor = scitex.ai.feature_extraction.VitFeatureExtractor(
+        model_name="B_16_imagenet1k"
+    )
+    tensor = torch.randn(3, 2, 4, 5, 32, 32)
+    processed = extractor.extract_features(tensor, (-2, -1), None)
+    print(processed.shape)
+
+    arr = np.random.rand(3, 2, 4, 5, 32, 32)
+    processed = extractor.extract_features(arr, (-2, -1), None)
+    print(processed.shape)
+    # torch.Size([3, 2, 4, 5, 32, 32])
+
+# EOF

scitex/ai/genai/__init__.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-25 12:00:00"
+# Author: Yusuke Watanabe (ywatanabe@alumni.u-tokyo.ac.jp)
+# scitex/src/scitex/ai/genai/__init__.py
+
+"""
+GenAI module for unified access to multiple AI providers.
+
+This module provides a consistent interface for interacting with various
+AI providers (OpenAI, Anthropic, Google, etc.) with built-in cost tracking,
+chat history management, and error handling.
+"""
+
+from typing import List, Dict, Any, Optional, Union
+import logging
+
+from .provider_factory import Provider, create_provider, GenAI as GenAIFactory
+from .auth_manager import AuthManager
+from .chat_history import ChatHistory
+from .cost_tracker import CostTracker
+from .response_handler import ResponseHandler
+from .base_provider import BaseProvider, CompletionResponse
+
+# Import legacy providers for backward compatibility
+from .anthropic import Anthropic
+from .openai import OpenAI
+from .google import Google
+from .groq import Groq
+from .deepseek import DeepSeek
+from .llama import Llama
+from .perplexity import Perplexity
+from .genai_factory import genai_factory
+
+logger = logging.getLogger(__name__)
+
+
+class GenAI:
+    """
+    Unified interface for multiple AI providers.
+
+    This class provides a consistent API for interacting with various AI providers
+    while handling authentication, chat history, cost tracking, and response processing.
+
+    Args:
+        provider: Provider name (e.g., 'openai', 'anthropic', 'google')
+        api_key: Optional API key (if not provided, will use environment variable)
+        model: Model name (if not provided, will use provider's default)
+        system_prompt: Optional system prompt to prepend to conversations
+        **kwargs: Additional provider-specific configuration
+
+    Example:
+        >>> from scitex.ai.genai import GenAI
+        >>>
+        >>> # Basic usage
+        >>> ai = GenAI(provider="openai")
+        >>> response = ai.complete("What is the capital of France?")
+        >>> print(response)
+        "The capital of France is Paris."
+        >>>
+        >>> # With specific model and system prompt
+        >>> ai = GenAI(
+        ...     provider="anthropic",
+        ...     model="claude-3-opus-20240229",
+        ...     system_prompt="You are a helpful geography expert."
+        ... )
+        >>> response = ai.complete("Tell me about Paris.")
+        >>>
+        >>> # Check costs
+        >>> print(ai.get_cost_summary())
+        "Total cost: $0.015 | Requests: 2 | Tokens: 1,234"
+    """
+
+    def __init__(
+        self,
+        provider: Union[str, Provider],
+        api_key: Optional[str] = None,
+        model: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+        **kwargs
+    ):
+        """Initialize GenAI with specified provider."""
+        # Store provider name
+        if isinstance(provider, str):
+            self.provider_name = provider.lower()
+        else:
+            self.provider_name = provider.value
+
+        # Initialize components
+        self.auth_manager = AuthManager(api_key, self.provider_name)
+        self.chat_history = ChatHistory(n_keep=-1)  # Keep all messages by default
+        self.response_handler = ResponseHandler()
+
+        # Get API key from auth manager if not provided
+        if api_key is None:
+            api_key = self.auth_manager.api_key
+
+        # Create provider instance
+        self.provider = create_provider(
+            provider=self.provider_name, api_key=api_key, model=model, **kwargs
+        )
+
+        # Initialize cost tracker with provider and model
+        # Note: provider instance may have a model attribute set during initialization
+        actual_model = getattr(self.provider, "model", None) or model or "unknown"
+        self.cost_tracker = CostTracker(provider=self.provider_name, model=actual_model)
+
+        # Add system prompt if provided
+        if system_prompt:
+            self.chat_history.add_message("system", system_prompt)
+
+        logger.info(f"Initialized GenAI with provider: {self.provider_name}")
+
+    def complete(
+        self, prompt: str, images: Optional[List[str]] = None, **kwargs
+    ) -> str:
+        """
+        Generate a completion for the given prompt.
+
+        Args:
+            prompt: The input prompt
+            images: Optional list of image URLs or base64 strings
+            **kwargs: Additional provider-specific parameters
+
+        Returns:
+            The generated response text
+
+        Raises:
+            ValueError: If the provider doesn't support images but images are provided
+            Exception: Provider-specific exceptions
+        """
+        # Add user message to history
+        self.chat_history.add_message("user", prompt, images)
+
+        # Get messages for API call
+        messages = [msg.to_dict() for msg in self.chat_history.get_messages()]
+
+        # Call provider
+        try:
+            response: CompletionResponse = self.provider.complete(
+                messages=messages, **kwargs
+            )
+        except Exception as e:
+            logger.error(f"Provider {self.provider_name} failed: {str(e)}")
+            raise
+
+        # Process response - CompletionResponse has a content attribute
+        content = response.content
+
+        # Add assistant message to history
+        self.chat_history.add_message("assistant", content)
+
+        # Track costs - CompletionResponse has input_tokens and output_tokens
+        self.cost_tracker.update(
+            input_tokens=response.input_tokens, output_tokens=response.output_tokens
+        )
+
+        return content
+
+    def complete_async(self, prompt: str, images: Optional[List[str]] = None, **kwargs):
+        """
+        Async version of complete method.
+
+        Args:
+            prompt: The input prompt
+            images: Optional list of image URLs or base64 strings
+            **kwargs: Additional provider-specific parameters
+
+        Returns:
+            Awaitable that resolves to the generated response text
+        """
+        raise NotImplementedError("Async completion not yet implemented")
+
+    def stream(self, prompt: str, images: Optional[List[str]] = None, **kwargs):
+        """
+        Stream completions for the given prompt.
+
+        Args:
+            prompt: The input prompt
+            images: Optional list of image URLs or base64 strings
+            **kwargs: Additional provider-specific parameters
+
+        Yields:
+            Chunks of the generated response
+        """
+        raise NotImplementedError("Streaming not yet implemented")
+
+    def clear_history(self):
+        """Clear the chat history."""
+        self.chat_history.clear()
+        logger.info("Chat history cleared")
+
+    def get_history(self) -> List[Dict[str, str]]:
+        """Get the current chat history."""
+        return self.chat_history.messages
+
+    def get_cost_summary(self) -> str:
+        """Get a summary of costs incurred."""
+        return self.cost_tracker.get_summary()
+
+    def get_detailed_costs(self) -> Dict[str, Any]:
+        """Get detailed cost breakdown."""
+        return {
+            "total_cost": self.cost_tracker.total_cost,
+            "total_prompt_tokens": self.cost_tracker.total_prompt_tokens,
+            "total_completion_tokens": self.cost_tracker.total_completion_tokens,
+            "request_count": self.cost_tracker.request_count,
+            "cost_by_model": self.cost_tracker.cost_by_model,
+        }
+
+    def reset_costs(self):
+        """Reset cost tracking."""
+        self.cost_tracker.reset()
+        logger.info("Cost tracking reset")
+
+    def __repr__(self) -> str:
+        """String representation of GenAI instance."""
+        return (
+            f"GenAI(provider='{self.provider_name}', "
+            f"model='{self.provider.model}', "
+            f"requests={self.cost_tracker.request_count})"
+        )
+
+
+# Convenience function for one-off completions
+def complete(
+    prompt: str,
+    provider: Union[str, Provider] = "openai",
+    model: Optional[str] = None,
+    api_key: Optional[str] = None,
+    **kwargs
+) -> str:
+    """
+    Convenience function for one-off completions without managing state.
+
+    Args:
+        prompt: The input prompt
+        provider: Provider name or enum
+        model: Optional model name
+        api_key: Optional API key
+        **kwargs: Additional parameters
+
+    Returns:
+        The generated response text
+
+    Example:
+        >>> from scitex.ai.genai import complete
+        >>> response = complete("What is 2+2?", provider="anthropic")
+        >>> print(response)
+        "2 + 2 = 4"
+    """
+    genai = GenAI(provider=provider, model=model, api_key=api_key)
+    return genai.complete(prompt, **kwargs)
+
+
+# Export public API
+__all__ = [
+    # New API
+    "GenAI",
+    "GenAIFactory",
+    "complete",
+    "Provider",
+    "create_provider",
+    "AuthManager",
+    "ChatHistory",
+    "CostTracker",
+    "ResponseHandler",
+    # Legacy API for backward compatibility
+    "genai_factory",
+    "Anthropic",
+    "OpenAI",
+    "Google",
+    "Groq",
+    "DeepSeek",
+    "Llama",
+    "Perplexity",
+]