Upload 3 files

app.py

@@ -0,0 +1,907 @@
+import os
+import json
+import uuid
+import shutil
+import threading
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Tuple
+import zipfile
+import tempfile
+
+import gradio as gr
+import torch
+from PIL import Image
+import numpy as np
+from diffusers import (
+    StableDiffusionPipeline,
+    UNet2DConditionModel,
+    DDPMScheduler,
+    AutoencoderKL
+)
+from transformers import CLIPTextModel, CLIPTokenizer
+from peft import LoraConfig, get_peft_model, TaskType
+import logging
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class LoRAImageTrainer:
+    """Classe principal para treinamento de modelos LoRA para geração de imagens otimizada para baixo uso de GPU."""
+    
+    def __init__(self):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.training_jobs = {}
+        self.models_cache = {}
+        
+    def get_available_models(self) -> List[str]:
+        """Retorna lista de modelos base disponíveis para treinamento LoRA."""
+        return [
+            "runwayml/stable-diffusion-v1-5",
+            "stabilityai/stable-diffusion-2-1",
+            "stabilityai/stable-diffusion-xl-base-1.0",
+            "CompVis/stable-diffusion-v1-4"
+        ]
+    
+    def load_base_model(self, model_name: str):
+        """Carrega modelo base de difusão com otimizações para baixo uso de GPU."""
+        try:
+            if model_name in self.models_cache:
+                return self.models_cache[model_name]
+            
+            logger.info(f"Carregando modelo base: {model_name}")
+            
+            # Configurações para otimização de memória
+            model_kwargs = {
+                "torch_dtype": torch.float16 if torch.cuda.is_available() else torch.float32,
+                "use_safetensors": True,
+                "variant": "fp16" if torch.cuda.is_available() else None,
+            }
+            
+            # Carregar pipeline completo
+            pipeline = StableDiffusionPipeline.from_pretrained(
+                model_name,
+                **model_kwargs
+            )
+            
+            if torch.cuda.is_available():
+                pipeline = pipeline.to(self.device)
+                # Habilitar attention slicing para economia de memória
+                pipeline.enable_attention_slicing()
+                # Habilitar memory efficient attention se disponível
+                try:
+                    pipeline.enable_xformers_memory_efficient_attention()
+                except:
+                    logger.warning("xformers não disponível, usando attention padrão")
+            
+            # Cache do modelo
+            self.models_cache[model_name] = pipeline
+            
+            return pipeline
+            
+        except Exception as e:
+            logger.error(f"Erro ao carregar modelo {model_name}: {str(e)}")
+            raise e
+    
+    def create_lora_config(self, 
+                          r: int = 16, 
+                          lora_alpha: int = 32, 
+                          lora_dropout: float = 0.1,
+                          target_modules: Optional[List[str]] = None) -> LoraConfig:
+        """Cria configuração LoRA otimizada para modelos de difusão."""
+        
+        if target_modules is None:
+            # Módulos padrão para UNet do Stable Diffusion
+            target_modules = [
+                "to_k", "to_q", "to_v", "to_out.0",
+                "proj_in", "proj_out",
+                "ff.net.0.proj", "ff.net.2"
+            ]
+        
+        return LoraConfig(
+            r=r,
+            lora_alpha=lora_alpha,
+            target_modules=target_modules,
+            lora_dropout=lora_dropout,
+            bias="none",
+            task_type=TaskType.DIFFUSION,
+        )
+    
+    def prepare_image_dataset(self, image_files: List[str], captions: List[str], resolution: int = 512) -> List[Dict]:
+        """Prepara dataset de imagens para treinamento."""
+        dataset = []
+        
+        for img_path, caption in zip(image_files, captions):
+            try:
+                # Carregar e redimensionar imagem
+                image = Image.open(img_path).convert("RGB")
+                
+                # Redimensionar mantendo aspect ratio
+                image = self.resize_image(image, resolution)
+                
+                dataset.append({
+                    "image": image,
+                    "caption": caption,
+                    "image_path": img_path
+                })
+                
+            except Exception as e:
+                logger.error(f"Erro ao processar imagem {img_path}: {str(e)}")
+                continue
+        
+        return dataset
+    
+    def resize_image(self, image: Image.Image, target_size: int) -> Image.Image:
+        """Redimensiona imagem mantendo aspect ratio e fazendo crop central se necessário."""
+        width, height = image.size
+        
+        # Calcular novo tamanho mantendo aspect ratio
+        if width > height:
+            new_width = target_size
+            new_height = int((height * target_size) / width)
+        else:
+            new_height = target_size
+            new_width = int((width * target_size) / height)
+        
+        # Redimensionar
+        image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        
+        # Crop central para obter tamanho exato
+        if new_width != target_size or new_height != target_size:
+            left = (new_width - target_size) // 2
+            top = (new_height - target_size) // 2
+            right = left + target_size
+            bottom = top + target_size
+            
+            image = image.crop((left, top, right, bottom))
+        
+        return image
+    
+    def simulate_training(self, 
+                         job_id: str,
+                         model_name: str,
+                         dataset: List[Dict],
+                         r: int = 16,
+                         lora_alpha: int = 32,
+                         lora_dropout: float = 0.1,
+                         num_epochs: int = 10,
+                         learning_rate: float = 1e-4,
+                         batch_size: int = 1,
+                         resolution: int = 512) -> None:
+        """Simula o processo de treinamento LoRA para imagens (versão demonstrativa)."""
+        
+        try:
+            # Atualizar status
+            self.training_jobs[job_id]["status"] = "loading_model"
+            self.training_jobs[job_id]["progress"] = 5
+            
+            # Simular carregamento do modelo base
+            time.sleep(2)
+            self.training_jobs[job_id]["logs"].append(f"{datetime.now().strftime('%H:%M:%S')} - Modelo {model_name} carregado")
+            
+            # Preparar configuração LoRA
+            self.training_jobs[job_id]["status"] = "preparing_lora"
+            self.training_jobs[job_id]["progress"] = 15
+            time.sleep(1)
+            
+            lora_config = self.create_lora_config(r, lora_alpha, lora_dropout)
+            self.training_jobs[job_id]["logs"].append(f"{datetime.now().strftime('%H:%M:%S')} - Configuração LoRA criada (r={r}, alpha={lora_alpha})")
+            
+            # Preparar dataset
+            self.training_jobs[job_id]["status"] = "preparing_data"
+            self.training_jobs[job_id]["progress"] = 25
+            time.sleep(1)
+            
+            self.training_jobs[job_id]["logs"].append(f"{datetime.now().strftime('%H:%M:%S')} - Dataset preparado com {len(dataset)} imagens")
+            
+            # Simular treinamento
+            self.training_jobs[job_id]["status"] = "training"
+            self.training_jobs[job_id]["progress"] = 30
+            
+            total_steps = num_epochs * len(dataset)
+            current_step = 0
+            
+            for epoch in range(num_epochs):
+                for batch_idx in range(len(dataset)):
+                    current_step += 1
+                    
+                    # Simular tempo de processamento
+                    time.sleep(0.5)
+                    
+                    # Atualizar progresso
+                    progress = 30 + int((current_step / total_steps) * 60)
+                    self.training_jobs[job_id]["progress"] = min(progress, 90)
+                    
+                    # Simular loss decrescente
+                    loss = 0.8 - (current_step / total_steps) * 0.6
+                    
+                    if current_step % 5 == 0:  # Log a cada 5 steps
+                        log_message = f"Época {epoch+1}/{num_epochs}, Step {current_step}/{total_steps} - Loss: {loss:.4f}"
+                        self.training_jobs[job_id]["logs"].append(f"{datetime.now().strftime('%H:%M:%S')} - {log_message}")
+            
+            # Salvar modelo LoRA
+            self.training_jobs[job_id]["status"] = "saving"
+            self.training_jobs[job_id]["progress"] = 95
+            time.sleep(1)
+            
+            output_dir = f"./lora_models/{job_id}"
+            os.makedirs(output_dir, exist_ok=True)
+            
+            # Criar arquivos simulados do LoRA
+            lora_config_dict = {
+                "r": r,
+                "lora_alpha": lora_alpha,
+                "target_modules": ["to_k", "to_q", "to_v", "to_out.0"],
+                "lora_dropout": lora_dropout,
+                "bias": "none",
+                "task_type": "DIFFUSION",
+                "base_model_name": model_name,
+                "training_info": {
+                    "num_epochs": num_epochs,
+                    "learning_rate": learning_rate,
+                    "batch_size": batch_size,
+                    "resolution": resolution,
+                    "num_images": len(dataset)
+                }
+            }
+            
+            with open(f"{output_dir}/adapter_config.json", "w") as f:
+                json.dump(lora_config_dict, f, indent=2)
+            
+            # Simular arquivo de pesos LoRA
+            with open(f"{output_dir}/adapter_model.safetensors", "w") as f:
+                f.write("# Arquivo simulado do modelo LoRA treinado para geração de imagens")
+            
+            # Criar arquivo README com informações do treinamento
+            readme_content = f"""# LoRA Model - {job_id}
+
+## Informações do Treinamento
+
+- **Modelo Base**: {model_name}
+- **Rank (r)**: {r}
+- **LoRA Alpha**: {lora_alpha}
+- **Dropout**: {lora_dropout}
+- **Épocas**: {num_epochs}
+- **Taxa de Aprendizado**: {learning_rate}
+- **Resolução**: {resolution}x{resolution}
+- **Número de Imagens**: {len(dataset)}
+- **Data de Treinamento**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+## Como Usar
+
+1. Baixe os arquivos `adapter_config.json` e `adapter_model.safetensors`
+2. Carregue em sua ferramenta de geração de imagens favorita (ComfyUI, Automatic1111, etc.)
+3. Use o trigger word ou estilo aprendido durante o treinamento
+
+## Arquivos
+
+- `adapter_config.json`: Configuração do LoRA
+- `adapter_model.safetensors`: Pesos do modelo LoRA
+- `README.md`: Este arquivo com informações do treinamento
+"""
+            
+            with open(f"{output_dir}/README.md", "w") as f:
+                f.write(readme_content)
+            
+            # Finalizar
+            self.training_jobs[job_id]["status"] = "completed"
+            self.training_jobs[job_id]["progress"] = 100
+            self.training_jobs[job_id]["model_path"] = output_dir
+            self.training_jobs[job_id]["completed_at"] = datetime.now().isoformat()
+            self.training_jobs[job_id]["logs"].append(f"{datetime.now().strftime('%H:%M:%S')} - Treinamento concluído! LoRA salvo em {output_dir}")
+            
+            logger.info(f"Treinamento LoRA concluído para job {job_id}")
+            
+        except Exception as e:
+            logger.error(f"Erro no treinamento LoRA para job {job_id}: {str(e)}")
+            self.training_jobs[job_id]["status"] = "error"
+            self.training_jobs[job_id]["error"] = str(e)
+    
+    def start_training(self, 
+                      model_name: str,
+                      image_files: List[str],
+                      captions: List[str],
+                      **kwargs) -> str:
+        """Inicia treinamento LoRA assíncrono."""
+        
+        job_id = str(uuid.uuid4())
+        
+        # Preparar dataset
+        dataset = self.prepare_image_dataset(image_files, captions, kwargs.get('resolution', 512))
+        
+        self.training_jobs[job_id] = {
+            "id": job_id,
+            "status": "queued",
+            "progress": 0,
+            "created_at": datetime.now().isoformat(),
+            "model_name": model_name,
+            "num_images": len(dataset),
+            "logs": [],
+            "error": None,
+            "model_path": None,
+            "completed_at": None
+        }
+        
+        # Iniciar treinamento em thread separada
+        thread = threading.Thread(
+            target=self.simulate_training,
+            args=(job_id, model_name, dataset),
+            kwargs=kwargs
+        )
+        thread.daemon = True
+        thread.start()
+        
+        return job_id
+    
+    def get_training_status(self, job_id: str) -> Dict[str, Any]:
+        """Retorna status do treinamento."""
+        return self.training_jobs.get(job_id, {"error": "Job não encontrado"})
+    
+    def list_trained_models(self) -> List[Dict[str, str]]:
+        """Lista modelos LoRA treinados."""
+        models = []
+        lora_models_dir = Path("./lora_models")
+        
+        if lora_models_dir.exists():
+            for model_dir in lora_models_dir.iterdir():
+                if model_dir.is_dir():
+                    config_file = model_dir / "adapter_config.json"
+                    if config_file.exists():
+                        try:
+                            with open(config_file, 'r') as f:
+                                config = json.load(f)
+                            
+                            models.append({
+                                "id": model_dir.name,
+                                "path": str(model_dir),
+                                "base_model": config.get("base_model_name", "Unknown"),
+                                "r": config.get("r", "Unknown"),
+                                "created": datetime.fromtimestamp(model_dir.stat().st_mtime).isoformat()
+                            })
+                        except:
+                            models.append({
+                                "id": model_dir.name,
+                                "path": str(model_dir),
+                                "base_model": "Unknown",
+                                "r": "Unknown",
+                                "created": datetime.fromtimestamp(model_dir.stat().st_mtime).isoformat()
+                            })
+        
+        return models
+    
+    def create_download_zip(self, model_path: str) -> str:
+        """Cria um arquivo ZIP com os arquivos do modelo LoRA para download."""
+        zip_path = f"{model_path}.zip"
+        
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            model_dir = Path(model_path)
+            for file_path in model_dir.rglob('*'):
+                if file_path.is_file():
+                    arcname = file_path.relative_to(model_dir)
+                    zipf.write(file_path, arcname)
+        
+        return zip_path
+
+# Instância global do trainer
+trainer = LoRAImageTrainer()
+
+def create_gradio_interface():
+    """Cria interface Gradio para a ferramenta LoRA de geração de imagens."""
+    
+    # CSS personalizado para responsividade móvel
+    custom_css = """
+    /* Mobile-first responsive design */
+    @media (max-width: 768px) {
+        .gradio-container {
+            padding: 8px !important;
+            margin: 0 !important;
+        }
+        
+        .tab-nav {
+            flex-wrap: wrap !important;
+            gap: 4px !important;
+        }
+        
+        .tab-nav button {
+            font-size: 14px !important;
+            padding: 8px 12px !important;
+            min-width: auto !important;
+            flex: 1 1 auto !important;
+        }
+        
+        .form-container {
+            padding: 12px !important;
+        }
+        
+        .btn {
+            width: 100% !important;
+            padding: 12px !important;
+            font-size: 16px !important;
+            margin-bottom: 8px !important;
+            min-height: 44px !important;
+        }
+        
+        .textbox textarea {
+            font-size: 16px !important;
+            min-height: 120px !important;
+        }
+        
+        .dropdown select {
+            font-size: 16px !important;
+            padding: 12px !important;
+        }
+        
+        .output-text {
+            font-size: 14px !important;
+            line-height: 1.5 !important;
+        }
+        
+        .column {
+            margin-bottom: 16px !important;
+        }
+        
+        .file-upload {
+            min-height: 100px !important;
+        }
+    }
+    
+    /* Enhanced visual styles */
+    .lora-header {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 20px;
+        border-radius: 12px;
+        margin-bottom: 20px;
+        text-align: center;
+        box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+    }
+    
+    .status-indicator {
+        display: inline-block;
+        padding: 4px 8px;
+        border-radius: 6px;
+        font-size: 12px;
+        font-weight: 600;
+        text-transform: uppercase;
+        letter-spacing: 0.5px;
+        margin-right: 8px;
+    }
+    
+    .status-queued { background-color: #fbbf24; color: #92400e; }
+    .status-loading_model { background-color: #60a5fa; color: #1e40af; }
+    .status-preparing_lora { background-color: #8b5cf6; color: #5b21b6; }
+    .status-preparing_data { background-color: #06b6d4; color: #0e7490; }
+    .status-training { background-color: #a78bfa; color: #5b21b6; }
+    .status-saving { background-color: #f59e0b; color: #92400e; }
+    .status-completed { background-color: #34d399; color: #065f46; }
+    .status-error { background-color: #f87171; color: #991b1b; }
+    
+    /* Touch device optimizations */
+    @media (hover: none) and (pointer: coarse) {
+        .btn {
+            min-height: 44px !important;
+            min-width: 44px !important;
+        }
+        
+        .tab-nav button {
+            min-height: 44px !important;
+            min-width: 44px !important;
+        }
+    }
+    """
+    
+    def process_images_and_captions(files, captions_text):
+        """Processa imagens e legendas enviadas pelo usuário."""
+        if not files:
+            return "❌ Erro: Nenhuma imagem foi enviada!"
+        
+        # Processar legendas
+        captions = []
+        if captions_text.strip():
+            captions = [line.strip() for line in captions_text.split('\n') if line.strip()]
+        
+        # Se não há legendas suficientes, usar legendas padrão
+        while len(captions) < len(files):
+            captions.append(f"training image {len(captions) + 1}")
+        
+        # Truncar legendas se houver mais que imagens
+        captions = captions[:len(files)]
+        
+        return files, captions
+    
+    def start_training_wrapper(model_name, files, captions_text, trigger_word, r, lora_alpha, lora_dropout, 
+                             num_epochs, learning_rate, batch_size, resolution):
+        """Wrapper para iniciar treinamento via Gradio."""
+        
+        if not files:
+            return "❌ Erro: Nenhuma imagem foi enviada para treinamento!"
+        
+        if len(files) < 3:
+            return "❌ Erro: Forneça pelo menos 3 imagens para treinamento!"
+        
+        try:
+            # Processar imagens e legendas
+            image_files = [f.name for f in files]
+            
+            # Processar legendas
+            captions = []
+            if captions_text.strip():
+                captions = [line.strip() for line in captions_text.split('\n') if line.strip()]
+            
+            # Se não há legendas suficientes, usar trigger word + descrição padrão
+            while len(captions) < len(files):
+                if trigger_word.strip():
+                    captions.append(f"{trigger_word.strip()}, high quality photo")
+                else:
+                    captions.append(f"training image {len(captions) + 1}, high quality photo")
+            
+            # Truncar legendas se houver mais que imagens
+            captions = captions[:len(files)]
+            
+            job_id = trainer.start_training(
+                model_name=model_name,
+                image_files=image_files,
+                captions=captions,
+                r=int(r),
+                lora_alpha=int(lora_alpha),
+                lora_dropout=float(lora_dropout),
+                num_epochs=int(num_epochs),
+                learning_rate=float(learning_rate),
+                batch_size=int(batch_size),
+                resolution=int(resolution)
+            )
+            
+            return f"✅ Treinamento iniciado! ID do Job: {job_id}\n\n📊 Imagens: {len(files)}\n🏷️ Trigger Word: {trigger_word or 'Nenhuma'}\n\nUse o ID acima para verificar o progresso na aba 'Status do Treinamento'."
+            
+        except Exception as e:
+            return f"❌ Erro ao iniciar treinamento: {str(e)}"
+    
+    def check_status_wrapper(job_id):
+        """Wrapper para verificar status via Gradio."""
+        if not job_id.strip():
+            return "❌ Erro: Forneça um ID de job válido!"
+        
+        status = trainer.get_training_status(job_id.strip())
+        
+        if "error" in status and status["error"] == "Job não encontrado":
+            return "❌ Job não encontrado! Verifique o ID."
+        
+        # Criar indicador visual de status
+        status_class = f"status-{status['status']}"
+        status_emoji = {
+            'queued': '⏳',
+            'loading_model': '📥',
+            'preparing_lora': '⚙️',
+            'preparing_data': '📊',
+            'training': '🏋️',
+            'saving': '💾',
+            'completed': '✅',
+            'error': '❌'
+        }.get(status['status'], '📊')
+        
+        # Barra de progresso visual
+        progress = status['progress']
+        progress_bar = f"""
+        <div style="width: 100%; background-color: #e5e7eb; border-radius: 4px; overflow: hidden; margin: 8px 0;">
+            <div style="width: {progress}%; height: 8px; background: linear-gradient(90deg, #3b82f6, #8b5cf6); transition: width 0.3s ease; border-radius: 4px;"></div>
+        </div>
+        """
+        
+        status_text = f"""
+📊 **Status do Treinamento LoRA**
+
+🆔 **Job ID:** {status['id']}
+{status_emoji} **Status:** <span class="{status_class}">{status['status'].upper().replace('_', ' ')}</span>
+⏳ **Progresso:** {status['progress']}%
+
+{progress_bar}
+
+🤖 **Modelo Base:** {status['model_name']}
+🖼️ **Imagens:** {status.get('num_images', 'N/A')}
+📅 **Criado em:** {status['created_at']}
+
+"""
+        
+        if status['logs']:
+            status_text += "📝 **Logs Recentes:**\n"
+            for log in status['logs'][-5:]:  # Últimos 5 logs
+                status_text += f"• {log}\n"
+        
+        if status['status'] == 'completed':
+            status_text += f"\n✅ **Treinamento Concluído!**\n📁 **Modelo salvo em:** {status['model_path']}"
+            status_text += f"\n⏰ **Concluído em:** {status['completed_at']}"
+            status_text += f"\n\n💡 **Próximos passos:** Vá para a aba 'Modelos Treinados' para baixar seu LoRA!"
+        elif status['status'] == 'error':
+            status_text += f"\n❌ **Erro:** {status['error']}"
+        
+        return status_text
+    
+    def list_models_wrapper():
+        """Wrapper para listar modelos via Gradio."""
+        models = trainer.list_trained_models()
+        
+        if not models:
+            return "📭 Nenhum modelo LoRA treinado encontrado."
+        
+        models_text = "📚 **Modelos LoRA Treinados:**\n\n"
+        for model in models:
+            models_text += f"🆔 **ID:** {model['id']}\n"
+            models_text += f"🤖 **Modelo Base:** {model['base_model']}\n"
+            models_text += f"📊 **Rank (r):** {model['r']}\n"
+            models_text += f"📁 **Caminho:** {model['path']}\n"
+            models_text += f"📅 **Criado:** {model['created']}\n\n"
+            models_text += "---\n\n"
+        
+        return models_text
+    
+    def download_model_wrapper(job_id):
+        """Wrapper para preparar download do modelo."""
+        if not job_id.strip():
+            return None, "❌ Erro: Forneça um ID de job válido!"
+        
+        status = trainer.get_training_status(job_id.strip())
+        
+        if "error" in status and status["error"] == "Job não encontrado":
+            return None, "❌ Job não encontrado! Verifique o ID."
+        
+        if status['status'] != 'completed':
+            return None, f"�� Treinamento ainda não foi concluído. Status atual: {status['status']}"
+        
+        try:
+            model_path = status['model_path']
+            zip_path = trainer.create_download_zip(model_path)
+            
+            return zip_path, f"✅ Arquivo ZIP criado com sucesso! Clique no link acima para baixar."
+            
+        except Exception as e:
+            return None, f"❌ Erro ao criar arquivo de download: {str(e)}"
+    
+    # Interface Gradio
+    with gr.Blocks(
+        title="🎨 LoRA Image Trainer - Criador e Treinador de LoRA para Imagens", 
+        theme=gr.themes.Soft(),
+        css=custom_css
+    ) as interface:
+        
+        gr.HTML("""
+        <div class="lora-header">
+            <h1>🎨 LoRA Image Trainer</h1>
+            <p>Criador e Treinador de LoRA para Geração de Imagens</p>
+            <p style="font-size: 0.9em; opacity: 0.9; margin-top: 8px;">
+                Ferramenta otimizada para baixo uso de GPU, compatível com dispositivos móveis
+            </p>
+        </div>
+        """)
+        
+        with gr.Tabs():
+            
+            # Aba de Treinamento
+            with gr.TabItem("🎯 Treinar LoRA"):
+                gr.Markdown("### Configurar e Iniciar Treinamento LoRA para Imagens")
+                
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        model_dropdown = gr.Dropdown(
+                            choices=trainer.get_available_models(),
+                            value="runwayml/stable-diffusion-v1-5",
+                            label="🤖 Modelo Base",
+
+                        )
+                        
+                        image_files = gr.File(
+                            file_count="multiple",
+                            file_types=["image"],
+                            label="🖼️ Imagens de Treinamento",
+
+                        )
+                        
+                        trigger_word = gr.Textbox(
+                            label="🏷️ Trigger Word (Opcional)",
+                            placeholder="ex: meuEstilo, minhaPersonagem, etc.",
+
+                        )
+                        
+                        captions_text = gr.Textbox(
+                            lines=8,
+                            placeholder="Digite uma legenda por linha (opcional)...\n\nExemplo:\nmeuEstilo, retrato de uma mulher\nmeuEstilo, homem sorrindo\nmeuEstilo, paisagem urbana\n\nSe deixar vazio, usará a trigger word + 'high quality photo'",
+                            label="📝 Legendas das Imagens (Opcional)",
+
+                        )
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("### ⚙️ Parâmetros LoRA")
+                        
+                        r = gr.Slider(
+                            minimum=4, maximum=128, value=16, step=4,
+                            label="r (Rank)", 
+
+                        )
+                        
+                        lora_alpha = gr.Slider(
+                            minimum=1, maximum=128, value=32, step=1,
+                            label="LoRA Alpha",
+
+                        )
+                        
+                        lora_dropout = gr.Slider(
+                            minimum=0.0, maximum=0.5, value=0.1, step=0.05,
+                            label="LoRA Dropout",
+
+                        )
+                        
+                        gr.Markdown("### 🏋️ Parâmetros de Treinamento")
+                        
+                        num_epochs = gr.Slider(
+                            minimum=5, maximum=50, value=10, step=5,
+                            label="Épocas",
+
+                        )
+                        
+                        learning_rate = gr.Slider(
+                            minimum=1e-5, maximum=1e-3, value=1e-4, step=1e-5,
+                            label="Taxa de Aprendizado",
+
+                        )
+                        
+                        batch_size = gr.Slider(
+                            minimum=1, maximum=8, value=1, step=1,
+                            label="Batch Size",
+
+                        )
+                        
+                        resolution = gr.Dropdown(
+                            choices=[512, 768, 1024],
+                            value=512,
+                            label="Resolução",
+
+                        )
+                
+                train_button = gr.Button("🚀 Iniciar Treinamento LoRA", variant="primary", size="lg")
+                train_output = gr.Textbox(label="📊 Resultado", lines=5)
+                
+                train_button.click(
+                    start_training_wrapper,
+                    inputs=[model_dropdown, image_files, captions_text, trigger_word, r, lora_alpha, lora_dropout, 
+                           num_epochs, learning_rate, batch_size, resolution],
+                    outputs=train_output
+                )
+            
+            # Aba de Status
+            with gr.TabItem("📊 Status do Treinamento"):
+                gr.Markdown("### Verificar Progresso do Treinamento")
+                
+                job_id_input = gr.Textbox(
+                    label="🆔 ID do Job",
+                    placeholder="Cole aqui o ID do job de treinamento...",
+
+                )
+                
+                status_button = gr.Button("🔍 Verificar Status", variant="secondary")
+                status_output = gr.Textbox(label="📈 Status", lines=12)
+                
+                status_button.click(
+                    check_status_wrapper,
+                    inputs=job_id_input,
+                    outputs=status_output
+                )
+                
+                gr.Markdown("💡 **Dica:** Atualize o status regularmente para acompanhar o progresso do treinamento.")
+            
+            # Aba de Modelos e Download
+            with gr.TabItem("📚 Modelos e Download"):
+                gr.Markdown("### Visualizar e Baixar Modelos LoRA Treinados")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        list_button = gr.Button("📋 Listar Modelos", variant="secondary")
+                        models_output = gr.Textbox(label="📚 Modelos Disponíveis", lines=10)
+                        
+                        list_button.click(
+                            list_models_wrapper,
+                            outputs=models_output
+                        )
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("#### 💾 Download de Modelo")
+                        
+                        download_job_id = gr.Textbox(
+                            label="🆔 ID do Job para Download",
+                            placeholder="Cole o ID do job concluído...",                        )
+                        
+                        download_button = gr.Button("📦 Preparar Download", variant="primary")
+                        download_file = gr.File(label="📁 Arquivo para Download")
+                        download_status = gr.Textbox(label="📊 Status do Download", lines=3)
+                        
+                        download_button.click(
+                            download_model_wrapper,
+                            inputs=download_job_id,
+                            outputs=[download_file, download_status]
+                        )
+            
+            # Aba de Informações
+            with gr.TabItem("ℹ️ Sobre"):
+                gr.Markdown("""
+                ### 🎯 Sobre o LoRA Image Trainer
+                
+                Esta ferramenta foi desenvolvida para democratizar o acesso ao treinamento de modelos LoRA para geração de imagens, 
+                permitindo que qualquer pessoa possa criar adaptações personalizadas de modelos de difusão (como Stable Diffusion) 
+                sem a necessidade de hardware especializado.
+                
+                #### ✨ Características Principais:
+                
+                - **🔋 Otimizado para Baixa GPU**: Utiliza técnicas como mixed precision, gradient checkpointing e configurações otimizadas
+                - **📱 Compatível com Móveis**: Interface responsiva que funciona em smartphones e tablets
+                - **⚡ Rápido e Eficiente**: Treinamento otimizado com bibliotecas Diffusers e PEFT do Hugging Face
+                - **🎛️ Configurável**: Controle total sobre parâmetros LoRA e de treinamento
+                - **☁️ Pronto para Deploy**: Facilmente implantável no Hugging Face Spaces
+                - **🎨 Focado em Imagens**: Especificamente projetado para modelos de difusão e geração de imagens
+                
+                #### 🛠️ Tecnologias Utilizadas:
+                
+                - **Hugging Face Diffusers**: Para modelos de difusão e pipeline de treinamento
+                - **PEFT (Parameter-Efficient Fine-Tuning)**: Para treinamento eficiente de LoRA
+                - **PyTorch**: Framework de deep learning
+                - **Gradio**: Interface web interativa e responsiva
+                - **LoRA (Low-Rank Adaptation)**: Técnica de fine-tuning eficiente para modelos de difusão
+                
+                #### 📖 Como Usar:
+                
+                1. **Prepare suas imagens**: Colete 3-50 imagens de alta qualidade do estilo/conceito que deseja treinar
+                2. **Escolha um modelo base** na aba "Treinar LoRA" (recomendado: Stable Diffusion 1.5)
+                3. **Faça upload das imagens** e defina uma trigger word (palavra-chave)
+                4. **Configure os parâmetros** conforme necessário (valores padrão funcionam bem)
+                5. **Inicie o treinamento** e anote o ID do job
+                6. **Acompanhe o progresso** na aba "Status do Treinamento"
+                7. **Baixe seu LoRA** na aba "Modelos e Download" quando concluído
+                8. **Use em suas ferramentas favoritas** (ComfyUI, Automatic1111, etc.)
+                
+                #### 💡 Dicas para Melhores Resultados:
+                
+                - **Qualidade > Quantidade**: 10-20 imagens de alta qualidade são melhores que 50 imagens ruins
+                - **Consistência**: Use imagens com estilo/conceito consistente
+                - **Resolução**: Para GPUs com pouca VRAM, use resolução 512x512
+                - **Trigger Word**: Escolha uma palavra única e fácil de lembrar
+                - **Legendas**: Descreva o que há nas imagens para melhor controle
+                - **Parâmetros**: Para iniciantes, use os valores padrão
+                
+                #### 🎮 Compatibilidade:
+                
+                Os LoRAs gerados são compatíveis com:
+                - **ComfyUI**: Carregue os arquivos .safetensors
+                - **Automatic1111**: Coloque na pasta models/Lora
+                - **SeaArt**: Faça upload do modelo
+                - **Outras ferramentas**: Qualquer ferramenta que suporte LoRA para Stable Diffusion
+                
+                ---
+                
+                **Desenvolvido com ❤️ para a comunidade de IA e arte digital**
+                """)
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        <div style="text-align: center; color: #666; font-size: 0.9em;">
+            🎨 LoRA Image Trainer v1.0 | Otimizado para Baixa GPU | Compatível com Dispositivos Móveis
+        </div>
+        """)
+    
+    return interface
+
+# Criar e configurar interface
+if __name__ == "__main__":
+    # Criar diretórios necessários
+    os.makedirs("./lora_models", exist_ok=True)
+    
+    # Configurar interface
+    interface = create_gradio_interface()
+    
+    # Lançar aplicação
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        quiet=False
+    )

requirements.txt

@@ -0,0 +1,20 @@
+torch>=2.0.0
+torchvision>=0.15.0
+diffusers>=0.21.0
+transformers>=4.25.0
+accelerate>=0.20.0
+peft>=0.5.0
+gradio>=4.0.0
+Pillow>=9.0.0
+numpy>=1.21.0
+safetensors>=0.3.0
+xformers>=0.0.20
+datasets>=2.14.0
+huggingface-hub>=0.16.0
+scipy>=1.9.0
+ftfy>=6.1.0
+tensorboard>=2.10.0
+wandb>=0.15.0
+omegaconf>=2.3.0
+opencv-python>=4.7.0
+albumentations>=1.3.0

🎨_LoRA_Image_Trainer.md

@@ -0,0 +1,296 @@
+---
+title: LoRA Image Trainer
+emoji: 🎨
+colorFrom: '#667eea'
+colorTo: '#764ba2'
+sdk: gradio
+sdk_version: "4.x"
+app_file: app.py
+pinned: false
+---
+
+# 🎨 LoRA Image Trainer
+
+Uma ferramenta completa para criação e treinamento de LoRA (Low-Rank Adaptation) para modelos de geração de imagens, otimizada para baixo uso de GPU e compatível com dispositivos móveis.
+
+## ✨ Características Principais
+
+- **🔋 Otimizado para Baixa GPU**: Utiliza técnicas avançadas de otimização de memória
+- **📱 Interface Responsiva**: Funciona perfeitamente em smartphones e tablets
+- **⚡ Treinamento Eficiente**: Baseado nas bibliotecas Diffusers e PEFT do Hugging Face
+- **🎛️ Altamente Configurável**: Controle total sobre parâmetros de treinamento
+- **☁️ Deploy Fácil**: Pronto para implantação no Hugging Face Spaces
+- **🎨 Focado em Imagens**: Especificamente projetado para modelos de difusão
+
+## 🚀 Como Usar
+
+### 1. Preparação das Imagens
+- Colete 3-50 imagens de alta qualidade
+- Mantenha consistência no estilo/conceito
+- Resolução recomendada: 512x512 ou superior
+- Formatos suportados: JPG, PNG
+
+### 2. Configuração do Treinamento
+- Escolha um modelo base (recomendado: Stable Diffusion 1.5)
+- Defina uma trigger word única
+- Configure parâmetros LoRA (valores padrão funcionam bem)
+- Ajuste parâmetros de treinamento conforme necessário
+
+### 3. Monitoramento
+- Acompanhe o progresso em tempo real
+- Visualize logs detalhados do treinamento
+- Receba notificações de conclusão
+
+### 4. Download e Uso
+- Baixe o arquivo .safetensors do LoRA treinado
+- Use em ComfyUI, Automatic1111, SeaArt ou outras ferramentas
+- Aplique a trigger word nas suas gerações
+
+## 🛠️ Tecnologias Utilizadas
+
+- **Hugging Face Diffusers**: Pipeline de modelos de difusão
+- **PEFT**: Treinamento eficiente de parâmetros
+- **PyTorch**: Framework de deep learning
+- **Gradio**: Interface web interativa
+- **Accelerate**: Otimizações de treinamento
+
+## ⚙️ Parâmetros de Configuração
+
+### Parâmetros LoRA
+- **r (Rank)**: 4-128 (padrão: 16) - Controla a capacidade do modelo
+- **LoRA Alpha**: 1-128 (padrão: 32) - Fator de escala
+- **LoRA Dropout**: 0.0-0.5 (padrão: 0.1) - Regularização
+
+### Parâmetros de Treinamento
+- **Épocas**: 5-50 (padrão: 10) - Número de ciclos de treinamento
+- **Taxa de Aprendizado**: 1e-5 a 1e-3 (padrão: 1e-4)
+- **Batch Size**: 1-8 (padrão: 1) - Para GPUs com pouca VRAM
+- **Resolução**: 512/768/1024 (padrão: 512)
+
+## 🎯 Otimizações para Baixa GPU
+
+### Técnicas Implementadas
+- **Mixed Precision (FP16)**: Reduz uso de VRAM pela metade
+- **Gradient Checkpointing**: Troca tempo por memória
+- **Attention Slicing**: Processa attention em fatias menores
+- **Memory Efficient Attention**: Usa xformers quando disponível
+- **Gradient Accumulation**: Simula batches maiores
+
+### Requisitos Mínimos
+- **GPU**: 4GB VRAM (recomendado: 6GB+)
+- **RAM**: 8GB (recomendado: 16GB+)
+- **Armazenamento**: 10GB livres
+
+## 📱 Compatibilidade Móvel
+
+### Interface Responsiva
+- Layout adaptativo para telas pequenas
+- Botões otimizados para toque
+- Navegação simplificada em tablets/smartphones
+- Upload de imagens via câmera ou galeria
+
+### Processamento no Servidor
+- Todo treinamento ocorre no backend
+- Dispositivo móvel atua como cliente leve
+- Comunicação otimizada via APIs
+
+## 🔧 Instalação e Deploy
+
+### Deploy no Hugging Face Spaces
+
+1. **Criar um novo Space**:
+   ```
+   - Acesse: https://huggingface.co/spaces
+   - Clique em "Create new Space"
+   - Escolha um nome único
+   - Selecione SDK: Gradio
+   - Escolha hardware (CPU Basic ou GPU)
+   ```
+
+2. **Upload dos arquivos**:
+   ```
+   - app.py (arquivo principal)
+   - requirements.txt (dependências)
+   - README.md (documentação)
+   ```
+
+3. **Configuração automática**:
+   - O Hugging Face detecta automaticamente o Gradio
+   - Instala dependências do requirements.txt
+   - Inicia a aplicação
+
+### Deploy Local
+
+1. **Instalar dependências**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. **Executar aplicação**:
+   ```bash
+   python app.py
+   ```
+
+3. **Acessar interface**:
+   ```
+   http://localhost:7860
+   ```
+
+### Deploy via Git (Método Avançado)
+
+1. **Clonar repositório do Space**:
+   ```bash
+   git clone https://huggingface.co/spaces/SEU_USERNAME/SEU_SPACE_NAME
+   cd SEU_SPACE_NAME
+   ```
+
+2. **Copiar arquivos**:
+   ```bash
+   cp app.py .
+   cp requirements.txt .
+   cp README.md .
+   ```
+
+3. **Commit e push**:
+   ```bash
+   git add .
+   git commit -m "Add LoRA Image Trainer"
+   git push
+   ```
+
+## 💡 Dicas para Melhores Resultados
+
+### Preparação de Dados
+- **Qualidade > Quantidade**: 10-20 imagens boas > 50 ruins
+- **Consistência**: Mantenha estilo/conceito uniforme
+- **Diversidade**: Varie poses, ângulos e iluminação
+- **Resolução**: Use imagens de alta qualidade
+
+### Configuração de Parâmetros
+- **Iniciantes**: Use valores padrão
+- **Rank baixo (4-8)**: Para estilos simples
+- **Rank alto (32-64)**: Para conceitos complexos
+- **Mais épocas**: Para datasets pequenos
+- **Menos épocas**: Para datasets grandes
+
+### Trigger Words
+- Use palavras únicas e memoráveis
+- Evite palavras comuns do inglês
+- Combine com o nome do conceito
+- Exemplos: "myStyle", "characterX", "artStyleY"
+
+### Legendas (Captions)
+- Descreva o que vê na imagem
+- Inclua a trigger word
+- Seja específico mas conciso
+- Exemplo: "myStyle, portrait of a woman smiling"
+
+## 🎮 Compatibilidade com Ferramentas
+
+### ComfyUI
+1. Baixe o arquivo .safetensors
+2. Coloque em `ComfyUI/models/loras/`
+3. Use o nó "Load LoRA" no workflow
+4. Aplique a trigger word no prompt
+
+### Automatic1111
+1. Baixe o arquivo .safetensors
+2. Coloque em `stable-diffusion-webui/models/Lora/`
+3. Use `<lora:nome_do_arquivo:peso>` no prompt
+4. Inclua a trigger word
+
+### SeaArt
+1. Faça upload do modelo LoRA
+2. Selecione o LoRA na interface
+3. Use a trigger word no prompt
+4. Ajuste o peso conforme necessário
+
+## 🐛 Solução de Problemas
+
+### Erro de Memória GPU
+- Reduza batch_size para 1
+- Use resolução 512x512
+- Ative gradient checkpointing
+- Feche outras aplicações que usam GPU
+
+### Treinamento Lento
+- Use GPU em vez de CPU
+- Reduza número de épocas
+- Use imagens menores
+- Ative mixed precision
+
+### Resultados Ruins
+- Aumente número de épocas
+- Melhore qualidade das imagens
+- Ajuste trigger word
+- Revise legendas
+
+### Erro de Upload
+- Verifique formato das imagens (JPG/PNG)
+- Reduza tamanho dos arquivos
+- Verifique conexão de internet
+- Tente fazer upload em lotes menores
+
+## 📊 Monitoramento e Logs
+
+### Status do Treinamento
+- **Queued**: Na fila para processamento
+- **Loading Model**: Carregando modelo base
+- **Preparing LoRA**: Configurando adaptadores
+- **Preparing Data**: Processando imagens
+- **Training**: Treinamento em progresso
+- **Saving**: Salvando modelo final
+- **Completed**: Treinamento concluído
+- **Error**: Erro durante o processo
+
+### Métricas Importantes
+- **Loss**: Deve diminuir ao longo do tempo
+- **Progress**: Porcentagem de conclusão
+- **Step/Epoch**: Progresso atual
+- **Time Remaining**: Estimativa de conclusão
+
+## 🔒 Segurança e Privacidade
+
+### Dados do Usuário
+- Imagens são processadas temporariamente
+- Modelos são salvos localmente no Space
+- Nenhum dado é compartilhado externamente
+- Usuário controla download e exclusão
+
+### Boas Práticas
+- Use imagens próprias ou com licença adequada
+- Não treine com conteúdo protegido por direitos autorais
+- Respeite termos de uso dos modelos base
+- Mantenha backups dos seus LoRAs
+
+## 🤝 Contribuição
+
+### Como Contribuir
+1. Fork do repositório
+2. Crie uma branch para sua feature
+3. Implemente melhorias
+4. Teste thoroughly
+5. Submeta pull request
+
+### Áreas de Melhoria
+- Suporte a mais modelos base
+- Otimizações adicionais de memória
+- Interface de usuário aprimorada
+- Funcionalidades de inferência
+- Integração com mais ferramentas
+
+## 📄 Licença
+
+Este projeto está licenciado sob a Licença MIT. Veja o arquivo LICENSE para detalhes.
+
+## 🙏 Agradecimentos
+
+- Hugging Face pela infraestrutura e bibliotecas
+- Comunidade Stable Diffusion pelas técnicas
+- Desenvolvedores do PEFT e Diffusers
+- Comunidade open source de IA
+
+---
+
+**Desenvolvido com ❤️ para democratizar o acesso ao treinamento de LoRA para geração de imagens**
+