force use GPU

src/domain/factories/detector_factory.py

@@ -31,6 +31,41 @@ load_dotenv()
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+def force_gpu_init():
+    """Força a inicialização da GPU."""
+    try:
+        # Forçar inicialização do CUDA
+        torch.cuda.init()
+        # Alocar e liberar um tensor pequeno para garantir que CUDA está funcionando
+        dummy = torch.cuda.FloatTensor(1)
+        del dummy
+        torch.cuda.empty_cache()
+        return True
+    except Exception as e:
+        logger.warning(f"Erro ao forçar inicialização da GPU: {str(e)}")
+        return False
+
+def is_gpu_available():
+    """Verifica se a GPU está disponível de forma mais robusta."""
+    try:
+        if not torch.cuda.is_available():
+            return False
+        
+        # Tentar forçar inicialização
+        if not force_gpu_init():
+            return False
+            
+        # Verificar se há memória disponível
+        gpu_memory = torch.cuda.get_device_properties(0).total_memory
+        if gpu_memory < 4 * (1024**3):  # Mínimo de 4GB
+            logger.warning("GPU encontrada mas com memória insuficiente")
+            return False
+            
+        return True
+    except Exception as e:
+        logger.warning(f"Erro ao verificar GPU: {str(e)}")
+        return False
+
 class BaseCache:
     """Cache base para armazenar resultados de detecção."""
     def __init__(self, max_size: int = 1000):
@@ -293,4 +328,23 @@ class WeaponDetector:
         # Forçar limpeza de memória
         gc.collect()
         if torch.cuda.is_available():
-            torch.cuda.empty_cache()
+            torch.cuda.empty_cache()
+
+class DetectorFactory:
+    """Factory para criar a instância apropriada do detector."""
+    
+    @staticmethod
+    def create_detector() -> BaseDetector:
+        """Cria e retorna a instância apropriada do detector."""
+        try:
+            # Forçar verificação robusta de GPU
+            if is_gpu_available():
+                logger.info("GPU disponível e inicializada com sucesso")
+                return WeaponDetectorGPU()
+            else:
+                logger.warning("GPU não disponível ou com problemas, usando CPU")
+                return WeaponDetectorCPU()
+        except Exception as e:
+            logger.error(f"Erro ao criar detector: {str(e)}")
+            logger.warning("Fallback para CPU devido a erro")
+            return WeaponDetectorCPU()

src/main.py

@@ -4,6 +4,7 @@ from src.presentation.web.gradio_interface import GradioInterface
 import logging
 import torch
 import gc
+from src.domain.factories.detector_factory import force_gpu_init, is_gpu_available
 
 # Configurar logging
 logging.basicConfig(
@@ -14,16 +15,21 @@ logger = logging.getLogger(__name__)
 
 def setup_zero_gpu():
     """Configurações otimizadas para Zero-GPU."""
-    # Limpar cache CUDA
-    if torch.cuda.is_available():
+    # Forçar inicialização da GPU
+    if is_gpu_available():
+        force_gpu_init()
+        # Limpar cache CUDA
         torch.cuda.empty_cache()
         gc.collect()
     
-    # Configurações para otimizar memória
-    os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:128'
-    torch.backends.cuda.matmul.allow_tf32 = True
-    torch.backends.cudnn.benchmark = True
-    torch.backends.cudnn.allow_tf32 = True
+        # Configurações para otimizar memória
+        os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:128'
+        torch.backends.cuda.matmul.allow_tf32 = True
+        torch.backends.cudnn.benchmark = True
+        torch.backends.cudnn.allow_tf32 = True
+        logger.info("Configurações Zero-GPU aplicadas com sucesso")
+    else:
+        logger.warning("GPU não disponível para configuração Zero-GPU")
 
 def main():
     """Função principal que inicia a aplicação."""
@@ -46,12 +52,13 @@ def main():
         
         if IS_HUGGINGFACE:
             # Calcular número ideal de workers baseado na GPU
-            if torch.cuda.is_available():
+            if is_gpu_available():
                 gpu_mem = torch.cuda.get_device_properties(0).total_memory / (1024**3)  # em GB
                 max_concurrent = 1  # Forçar single worker para Zero-GPU
                 logger.info(f"GPU Memory: {gpu_mem:.1f}GB, Max Concurrent: {max_concurrent}")
             else:
                 max_concurrent = 1
+                logger.warning("GPU não disponível, usando configuração mínima")
             
             # Primeiro configurar a fila
             demo = demo.queue(