isa-model 0.2.0__py3-none-any.whl → 0.2.9__py3-none-any.whl

isa_model/training/image_model/raw_data/pre_processing.py

@@ -1,200 +0,0 @@
-import os
-import cv2
-import logging
-from PIL import Image
-from pathlib import Path
-from tqdm import tqdm
-from concurrent.futures import ProcessPoolExecutor
-import shutil
-from ultralytics import YOLO
-import numpy
-from pillow_heif import register_heif_opener
-
-# Configure logging and PIL settings
-logging.basicConfig(level=logging.INFO)
-Image.MAX_IMAGE_PIXELS = None
-register_heif_opener()  # This enables HEIC support in PIL
-
-COCO_CLASSES = {
-    'person': 0, 'bicycle': 1, 'car': 2, 'motorcycle': 3, 'airplane': 4, 'bus': 5, 'train': 6,
-    'truck': 7, 'boat': 8, 'traffic light': 9, 'fire hydrant': 10, 'stop sign': 11,
-    'parking meter': 12, 'bench': 13, 'bird': 14, 'cat': 15, 'dog': 16, 'horse': 17,
-    'sheep': 18, 'cow': 19, 'elephant': 20, 'bear': 21, 'zebra': 22, 'giraffe': 23,
-    'backpack': 24, 'umbrella': 25, 'handbag': 26, 'tie': 27, 'suitcase': 28, 'frisbee': 29,
-    'skis': 30, 'snowboard': 31, 'sports ball': 32, 'kite': 33, 'baseball bat': 34,
-    'baseball glove': 35, 'skateboard': 36, 'surfboard': 37, 'tennis racket': 38,
-    'bottle': 39, 'wine glass': 40, 'cup': 41, 'fork': 42, 'knife': 43, 'spoon': 44,
-    'bowl': 45, 'banana': 46, 'apple': 47, 'sandwich': 48, 'orange': 49, 'broccoli': 50,
-    'carrot': 51, 'hot dog': 52, 'pizza': 53, 'donut': 54, 'cake': 55, 'chair': 56,
-    'couch': 57, 'potted plant': 58, 'bed': 59, 'dining table': 60, 'toilet': 61,
-    'tv': 62, 'laptop': 63, 'mouse': 64, 'remote': 65, 'keyboard': 66, 'cell phone': 67,
-    'microwave': 68, 'oven': 69, 'toaster': 70, 'sink': 71, 'refrigerator': 72,
-    'book': 73, 'clock': 74, 'vase': 75, 'scissors': 76, 'teddy bear': 77,
-    'hair drier': 78, 'toothbrush': 79
-}
-
-class ImagePreProcessor:
-    def __init__(self, input_dir: str, output_dir: str, target_size: tuple = (512, 512), 
-                 padding: float = 0.3):
-        """
-        Initialize the image preprocessor
-        """
-        self.input_dir = Path(input_dir)
-        self.output_dir = Path(output_dir)
-        self.target_size = target_size
-        self.padding = padding
-        self.supported_formats = {'.jpg', '.jpeg', '.heic', '.png'}
-        
-        # Load YOLO face detection model
-        try:
-            logging.info("Loading YOLO face detection model...")
-            current_dir = Path(__file__).parent  # Get the directory where this script is located
-            model_path = current_dir / "models" / "yolov8n-face.pt"
-            
-            if not os.path.exists(model_path):
-                raise FileNotFoundError(f"Model file not found at {model_path}")
-            self.model = YOLO(str(model_path))  # Convert Path to string for YOLO
-            logging.info("Successfully loaded YOLO face detection model")
-        except Exception as e:
-            logging.error(f"Failed to load YOLO model: {str(e)}")
-            raise
-
-        self.output_dir.mkdir(parents=True, exist_ok=True)
-
-    def detect_and_crop_face(self, img) -> tuple:
-        """
-        Detect face in image and return cropped region
-        """
-        cv2_img = cv2.cvtColor(numpy.array(img), cv2.COLOR_RGB2BGR)
-        results = self.model(cv2_img)
-        
-        # Get all face detections
-        detections = results[0].boxes
-        
-        if len(detections) == 0:
-            return False, None
-            
-        # Get coordinates of the first detected face
-        box = detections[0]
-        x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
-        
-        # Add padding
-        width = x2 - x1
-        height = y2 - y1
-        padding_x = int(width * self.padding)
-        padding_y = int(height * self.padding)
-        
-        x1 = max(0, x1 - padding_x)
-        y1 = max(0, y1 - padding_y)
-        x2 = min(img.width, x2 + padding_x)
-        y2 = min(img.height, y2 + padding_y)
-        
-        cropped_img = img.crop((x1, y1, x2, y2))
-        return True, cropped_img
-
-    def process_image(self, image_path: Path) -> tuple:
-        """
-        Process a single image
-        
-        Args:
-            image_path (Path): Path to input image
-            
-        Returns:
-            tuple: (success, message)
-        """
-        try:
-            # Handle HEIC/HEIF files
-            if image_path.suffix.lower() in {'.heic', '.heif'}:
-                try:
-                    with Image.open(image_path) as img:
-                        # Convert HEIC to RGB mode
-                        img = img.convert('RGB')
-                        detected, cropped_img = self.detect_and_crop_face(img)
-                        if not detected:
-                            return False, f"No face detected in {image_path.name}"
-                except Exception as e:
-                    return False, f"Error processing HEIC file {image_path.name}: {str(e)}"
-            else:
-                # Handle other image formats
-                with Image.open(image_path) as img:
-                    if img.mode != 'RGB':
-                        img = img.convert('RGB')
-                    detected, cropped_img = self.detect_and_crop_face(img)
-                    if not detected:
-                        return False, f"No face detected in {image_path.name}"
-            
-            # Process the cropped image
-            aspect_ratio = cropped_img.width / cropped_img.height
-            if aspect_ratio > 1:
-                new_width = self.target_size[0]
-                new_height = int(self.target_size[0] / aspect_ratio)
-            else:
-                new_height = self.target_size[1]
-                new_width = int(self.target_size[1] * aspect_ratio)
-
-            cropped_img = cropped_img.resize((new_width, new_height), Image.LANCZOS)
-            
-            new_img = Image.new('RGB', self.target_size, (0, 0, 0))
-            paste_x = (self.target_size[0] - new_width) // 2
-            paste_y = (self.target_size[1] - new_height) // 2
-            new_img.paste(cropped_img, (paste_x, paste_y))
-            
-            output_path = self.output_dir / f"{image_path.stem}.jpg"
-            new_img.save(output_path, 'JPEG', quality=95)
-            
-            return True, f"Successfully processed {image_path.name}"
-
-        except Exception as e:
-            return False, f"Error processing {image_path.name}: {str(e)}"
-
-    def process_directory(self, num_workers: int = 4):
-        """
-        Process all images in the input directory
-        
-        Args:
-            num_workers (int): Number of worker processes to use
-        """
-        # Get list of all images
-        image_files = [
-            f for f in self.input_dir.iterdir() 
-            if f.is_file() and f.suffix.lower() in self.supported_formats
-        ]
-        
-        if not image_files:
-            logging.warning("No supported image files found in input directory")
-            return
-
-        logging.info(f"Found {len(image_files)} images to process")
-        
-        # Process images using multiple workers
-        with ProcessPoolExecutor(max_workers=num_workers) as executor:
-            with tqdm(total=len(image_files), desc="Processing images") as pbar:
-                futures = []
-                for image_path in image_files:
-                    future = executor.submit(self.process_image, image_path)
-                    future.add_done_callback(lambda p: pbar.update(1))
-                    futures.append(future)
-                
-                # Process results
-                for future in futures:
-                    success, message = future.result()
-                    if not success:
-                        logging.error(message)
-
-def main():
-    # Update paths to use project-relative directories
-    current_dir = Path(__file__).parent  # Get the directory where this script is located
-    input_dir = current_dir / "data" / "training_images"
-    output_dir = current_dir / "data" / "training_images_processed"
-    
-    processor = ImagePreProcessor(
-        input_dir=input_dir,
-        output_dir=output_dir,
-        target_size=(512, 512),  # Good size for Kohya training
-        padding=0.3,             # 30% padding around faces
-    )
-    
-    processor.process_directory(num_workers=4)
-
-if __name__ == "__main__":
-    main()

isa_model/training/image_model/train/train.py

@@ -1,42 +0,0 @@
-import json
-import subprocess
-from pathlib import Path
-
-def train_lora():
-    # Load your config
-    with open('training_config.json', 'r') as f:
-        config = json.load(f)
-    
-    # Construct the training command
-    cmd = [
-        "accelerate", "launch",
-        "--num_cpu_threads_per_process", str(config["num_cpu_threads_per_process"]),
-        "train_network.py",
-        "--pretrained_model_name_or_path", config["pretrained_model_name_or_path"],
-        "--train_data_dir", config["train_data_dir"],
-        "--output_dir", config["output_dir"],
-        "--output_name", config["output_name"],
-        "--save_model_as", config["save_model_as"],
-        "--learning_rate", str(config["learning_rate"]),
-        "--train_batch_size", str(config["train_batch_size"]),
-        "--epoch", str(config["epoch"]),
-        "--save_every_n_epochs", str(config["save_every_n_epochs"]),
-        "--mixed_precision", config["mixed_precision"],
-        "--cache_latents",
-        "--gradient_checkpointing"
-    ]
-
-    # Add FLUX specific parameters
-    if config.get("flux1_checkbox"):
-        cmd.extend([
-            "--flux1_t5xxl", config["flux1_t5xxl"],
-            "--flux1_clip_l", config["flux1_clip_l"],
-            "--flux1_cache_text_encoder_outputs",
-            "--flux1_cache_text_encoder_outputs_to_disk"
-        ])
-
-    # Execute the training
-    subprocess.run(cmd, check=True)
-
-if __name__ == "__main__":
-    train_lora() 

isa_model/training/image_model/train/train_flux.py

@@ -1,41 +0,0 @@
-import json
-import subprocess
-from pathlib import Path
-
-def train_flux():
-    # Load your config
-    with open('flux_config.json', 'r') as f:
-        config = json.load(f)
-    
-    # Construct the training command for Flux finetuning
-    cmd = [
-        "accelerate", "launch",
-        "--num_cpu_threads_per_process", str(config["num_cpu_threads_per_process"]),
-        "train_db.py",
-        "--pretrained_model_name_or_path", config["pretrained_model_name_or_path"],
-        "--train_data_dir", config["train_data_dir"],
-        "--output_dir", config["output_dir"],
-        "--output_name", config["output_name"],
-        "--train_batch_size", str(config["train_batch_size"]),
-        "--save_every_n_epochs", str(config["save_every_n_epochs"]),
-        "--learning_rate", str(config["learning_rate"]),
-        "--max_train_epochs", str(config["epoch"]),
-        "--mixed_precision", config["mixed_precision"],
-        "--save_model_as", config["save_model_as"],
-        "--cache_latents",
-        "--cache_latents_to_disk",
-        "--gradient_checkpointing",
-        "--optimizer_type", "Adafactor",
-        "--optimizer_args", "scale_parameter=False relative_step=False warmup_init=False weight_decay=0.01",
-        "--max_resolution", "1024,1024",
-        "--full_bf16",
-        "--flux1_checkbox",
-        "--flux1_t5xxl", config["flux1_t5xxl"],
-        "--flux1_clip_l", config["flux1_clip_l"],
-        "--flux1_cache_text_encoder_outputs",
-        "--flux1_cache_text_encoder_outputs_to_disk",
-        "--flux_fused_backward_pass"
-    ]
-
-    # Execute the training
-    subprocess.run(cmd, check=True) 

isa_model/training/image_model/train/train_lora.py

@@ -1,57 +0,0 @@
-import json
-import subprocess
-from pathlib import Path
-
-def train_lora():
-    # Load your config
-    with open('training_config.json', 'r') as f:
-        config = json.load(f)
-    
-    # Construct the training command for LoRA
-    cmd = [
-        "accelerate", "launch",
-        "--num_cpu_threads_per_process", str(config["num_cpu_threads_per_process"]),
-        "sdxl_train_network.py",  # Use the SDXL LoRA training script
-        "--network_module", "networks.lora",  # Specify LoRA network
-        "--pretrained_model_name_or_path", config["pretrained_model_name_or_path"],
-        "--train_data_dir", config["train_data_dir"],
-        "--output_dir", config["output_dir"],
-        "--output_name", config["output_name"],
-        "--save_model_as", config["save_model_as"],
-        "--network_alpha", "1",  # LoRA alpha parameter
-        "--network_dim", "32",   # LoRA dimension
-        "--learning_rate", str(config["learning_rate"]),
-        "--train_batch_size", str(config["train_batch_size"]),
-        "--max_train_epochs", str(config["epoch"]),
-        "--save_every_n_epochs", str(config["save_every_n_epochs"]),
-        "--mixed_precision", config["mixed_precision"],
-        "--cache_latents",
-        "--gradient_checkpointing",
-        "--network_args", "conv_dim=32", "conv_alpha=1",  # LoRA network arguments
-        "--noise_offset", "0.1",
-        "--adaptive_noise_scale", "0.01",
-        "--max_resolution", "1024,1024",
-        "--min_bucket_reso", "256",
-        "--max_bucket_reso", "1024",
-        "--xformers",
-        "--bucket_reso_steps", "64",
-        "--caption_extension", ".txt",
-        "--optimizer_type", "AdaFactor",
-        "--optimizer_args", "scale_parameter=False", "relative_step=False", "warmup_init=False",
-        "--lr_scheduler", "constant"
-    ]
-
-    # Add FLUX specific parameters for LoRA
-    if config.get("flux1_checkbox"):
-        cmd.extend([
-            "--flux1_t5xxl", config["flux1_t5xxl"],
-            "--flux1_clip_l", config["flux1_clip_l"],
-            "--flux1_cache_text_encoder_outputs",
-            "--flux1_cache_text_encoder_outputs_to_disk"
-        ])
-
-    # Execute the training
-    subprocess.run(cmd, check=True)
-
-if __name__ == "__main__":
-    train_lora() 

isa_model/training/image_model/train_main.py

@@ -1,25 +0,0 @@
-import os
-from pathlib import Path
-import shutil
-from app.services.training.image_model.raw_data.create_lora_captions import create_lora_captions
-from app.services.training.image_model.train.train_flux import train_flux
-
-def main():
-    # Setup paths
-    project_root = Path(__file__).parent
-    processed_images_dir = project_root / "raw_data/training_images_processed"
-    
-    # 1. Generate captions for all processed images
-    print("Creating captions for processed images...")
-    create_lora_captions(processed_images_dir)
-    
-    # 2. Create Flux config
-    print("Creating Flux configuration...")
-    os.system(f"python {project_root}/configs/create_flux_config.py")
-    
-    # 3. Run Flux training
-    print("Starting Flux training...")
-    train_flux()
-
-if __name__ == "__main__":
-    main() 

isa_model-0.2.0.dist-info/METADATA

@@ -1,327 +0,0 @@
-Metadata-Version: 2.4
-Name: isa-model
-Version: 0.2.0
-Summary: Unified AI model serving framework
-Author-email: isA_Model Contributors <your.email@example.com>
-License-Expression: MIT
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: fastapi>=0.95.0
-Requires-Dist: numpy>=1.20.0
-Requires-Dist: httpx>=0.23.0
-Requires-Dist: pydantic>=2.0.0
-Requires-Dist: uvicorn>=0.22.0
-Requires-Dist: requests>=2.28.0
-Requires-Dist: aiohttp>=3.8.0
-Requires-Dist: transformers>=4.30.0
-Requires-Dist: langchain-core>=0.1.0
-Requires-Dist: huggingface-hub>=0.16.0
-Requires-Dist: kubernetes>=25.3.0
-Requires-Dist: mlflow>=2.4.0
-Requires-Dist: torch>=2.0.0
-Requires-Dist: openai>=1.10.0
-Requires-Dist: replicate>=0.23.0
-Requires-Dist: python-dotenv>=1.0.0
-Dynamic: license-file
-
-# isA Model - Unified AI Model Serving Framework
-
-A comprehensive Python framework for working with multiple AI providers and models through a unified interface. Support for OpenAI, Replicate, Ollama, and more.
-
-## Installation
-
-```bash
-pip install isa-model
-```
-
-## Quick Start
-
-The isa-model package supports three main usage patterns:
-
-### 1. Pass API Keys Directly (Recommended)
-
-This is the most flexible approach - no environment variables needed:
-
-```python
-from isa_model.inference.ai_factory import AIFactory
-
-# Create factory instance
-factory = AIFactory.get_instance()
-
-# Use OpenAI with API key
-llm = factory.get_llm(
-    model_name="gpt-4o-mini", 
-    provider="openai", 
-    api_key="your-openai-api-key-here"
-)
-
-# Use Replicate for image generation
-image_gen = factory.get_vision_model(
-    model_name="stability-ai/sdxl", 
-    provider="replicate", 
-    api_key="your-replicate-token-here"
-)
-```
-
-### 2. Use Environment Variables
-
-Set your API keys as environment variables:
-
-```bash
-export OPENAI_API_KEY="your-openai-api-key"
-export REPLICATE_API_TOKEN="your-replicate-token"
-```
-
-Then use without passing keys:
-
-```python
-from isa_model.inference.ai_factory import AIFactory
-
-factory = AIFactory.get_instance()
-
-# Will automatically use OPENAI_API_KEY from environment
-llm = factory.get_llm(model_name="gpt-4o-mini", provider="openai")
-
-# Will automatically use REPLICATE_API_TOKEN from environment  
-image_gen = factory.get_vision_model(model_name="stability-ai/sdxl", provider="replicate")
-```
-
-### 3. Use Local Models (No API Key Needed)
-
-For local models like Ollama, no API keys are required:
-
-```python
-from isa_model.inference.ai_factory import AIFactory
-
-factory = AIFactory.get_instance()
-
-# Use local Ollama model (no API key needed)
-llm = factory.get_llm(model_name="llama3.1", provider="ollama")
-```
-
-## Supported Services
-
-### Language Models (LLM)
-
-```python
-# OpenAI models
-llm = factory.get_llm("gpt-4o-mini", "openai", api_key="your-key")
-llm = factory.get_llm("gpt-4o", "openai", api_key="your-key") 
-
-# Ollama models (local)
-llm = factory.get_llm("llama3.1", "ollama")
-llm = factory.get_llm("codellama", "ollama")
-
-# Replicate models
-llm = factory.get_llm("meta/llama-3-70b-instruct", "replicate", api_key="your-token")
-```
-
-### Vision Models
-
-```python
-# OpenAI vision
-vision = factory.get_vision_model("gpt-4o", "openai", api_key="your-key")
-
-# Replicate image generation
-image_gen = factory.get_vision_model("stability-ai/sdxl", "replicate", api_key="your-token")
-
-# Ollama vision (local)
-vision = factory.get_vision_model("llava", "ollama")
-```
-
-### Embedding Models
-
-```python
-# OpenAI embeddings
-embedder = factory.get_embedding("text-embedding-3-small", "openai", {"api_key": "your-key"})
-
-# Ollama embeddings (local)
-embedder = factory.get_embedding("bge-m3", "ollama")
-```
-
-## Base Service Classes
-
-The framework provides comprehensive base classes for implementing new AI services:
-
-### BaseLLMService
-- `ainvoke()` - Universal invocation method
-- `achat()` - Chat completion with messages
-- `acompletion()` - Simple text completion
-- `agenerate()` - Generate multiple completions
-- `astream_chat()` - Streaming chat responses
-- `get_token_usage()` - Token usage statistics
-
-### BaseVisionService  
-- `analyze_image()` - Analyze and describe images
-- `describe_image()` - Generate detailed descriptions
-- `extract_text()` - OCR text extraction
-- `detect_objects()` - Object detection
-- `classify_image()` - Image classification
-- `compare_images()` - Image similarity comparison
-
-### BaseImageGenService
-- `generate_image()` - Generate single image from text
-- `generate_images()` - Generate multiple images
-- `image_to_image()` - Transform existing images
-- `get_supported_sizes()` - Get supported dimensions
-
-### BaseEmbedService
-- `create_text_embedding()` - Single text embedding
-- `create_text_embeddings()` - Batch text embeddings
-- `compute_similarity()` - Similarity calculation
-- `find_similar_texts()` - Semantic search
-
-### BaseSTTService (Speech-to-Text)
-- `transcribe_audio()` - Audio transcription
-- `transcribe_audio_batch()` - Batch transcription
-- `detect_language()` - Language detection
-
-### BaseTTSService (Text-to-Speech)
-- `synthesize_speech()` - Text to speech conversion
-- `synthesize_speech_to_file()` - Save speech to file
-- `get_available_voices()` - List available voices
-
-## Usage Examples
-
-### Chat Completion
-
-```python
-import asyncio
-from isa_model.inference.ai_factory import AIFactory
-
-async def chat_example():
-    factory = AIFactory.get_instance()
-    llm = factory.get_llm("gpt-4o-mini", "openai", api_key="your-key")
-    
-    messages = [
-        {"role": "user", "content": "Hello, how are you?"}
-    ]
-    
-    response = await llm.achat(messages)
-    print(response)
-
-# Run the async function
-asyncio.run(chat_example())
-```
-
-### Image Analysis
-
-```python
-import asyncio
-from isa_model.inference.ai_factory import AIFactory
-
-async def vision_example():
-    factory = AIFactory.get_instance()
-    vision = factory.get_vision_model("gpt-4o", "openai", api_key="your-key")
-    
-    result = await vision.analyze_image(
-        image="path/to/your/image.jpg",
-        prompt="What do you see in this image?"
-    )
-    
-    print(result["text"])
-
-asyncio.run(vision_example())
-```
-
-### Image Generation
-
-```python
-import asyncio
-from isa_model.inference.ai_factory import AIFactory
-
-async def image_gen_example():
-    factory = AIFactory.get_instance()
-    image_gen = factory.get_vision_model(
-        "stability-ai/sdxl", 
-        "replicate", 
-        api_key="your-replicate-token"
-    )
-    
-    result = await image_gen.generate_image(
-        prompt="A beautiful sunset over mountains",
-        width=1024,
-        height=1024
-    )
-    
-    # Save the generated image
-    with open("generated_image.png", "wb") as f:
-        f.write(result["image_data"])
-
-asyncio.run(image_gen_example())
-```
-
-## Configuration Options
-
-You can pass additional configuration options:
-
-```python
-# Custom configuration
-config = {
-    "temperature": 0.7,
-    "max_tokens": 1000,
-    "top_p": 0.9
-}
-
-llm = factory.get_llm(
-    model_name="gpt-4o-mini",
-    provider="openai", 
-    config=config,
-    api_key="your-key"
-)
-```
-
-## Error Handling
-
-The framework provides informative error messages and graceful fallbacks:
-
-```python
-try:
-    llm = factory.get_llm("gpt-4o-mini", "openai", api_key="invalid-key")
-    response = await llm.achat([{"role": "user", "content": "Hello"}])
-except Exception as e:
-    print(f"Error: {e}")
-```
-
-## Development
-
-### Installing for Development
-
-```bash
-git clone <repository-url>
-cd isA_Model
-pip install -e .
-```
-
-### Running Tests
-
-```bash
-pytest tests/
-```
-
-### Building and Publishing
-
-```bash
-# Build the package
-python -m build
-
-# Upload to PyPI (requires PYPI_API_TOKEN in .env.local)
-bash scripts/normal_update.sh
-```
-
-## License
-
-MIT License - see LICENSE file for details.
-
-## Contributing
-
-Contributions are welcome! Please read our contributing guidelines and submit pull requests to our GitHub repository.
-
-## Support
-
-For questions and support, please open an issue on our GitHub repository.