feat: atualização do detector com otimizações para GPU T4

.env.example

@@ -29,7 +29,6 @@ NOTIFICATION_EMAIL=""  # E-mail para envio de notificações
 HUGGING_FACE_TOKEN=""  # Token do Hugging Face para acesso aos modelos
 TOKENIZERS_PARALLELISM=false
 MODEL_CACHE_DIR=./.model_cache
-BATCH_SIZE=16
 MAX_WORKERS=2
 USE_HALF_PRECISION=true
 DETECTION_CONFIDENCE_THRESHOLD=0.5
@@ -50,3 +49,42 @@ CUDA_VISIBLE_DEVICES=0
 TORCH_CUDA_ARCH_LIST="7.5"
 NVIDIA_VISIBLE_DEVICES=all
 NVIDIA_DRIVER_CAPABILITIES=compute,utility
+
+# Configurações do modelo
+MODEL_NAME=google/owlv2-base-patch16
+DEVICE=cuda:0
+THRESHOLD=0.3
+FPS=2
+RESOLUTION=640
+
+# Configurações de logging
+LOG_LEVEL=INFO
+LOG_FORMAT=%(asctime)s - %(name)s - %(levelname)s - %(message)s
+
+# Configurações de memória
+MAX_MEMORY=8GB
+OFFLOAD_FOLDER=offload
+
+# Configurações de otimização
+TORCH_COMPILE=false
+HALF_PRECISION=true
+
+# Configurações de interface
+THEME=default
+ALLOW_FLAGGING=false
+ALLOW_SCREENSHOT=true
+SHOW_API=true
+
+# Configurações de segurança
+AUTHENTICATION=false
+USERNAME=admin
+PASSWORD=admin
+
+# Configurações de monitoramento
+ENABLE_QUEUE=true
+MAX_THREADS=4
+CONCURRENCY_COUNT=1
+
+# Configurações de armazenamento
+SAVE_OUTPUTS=false
+OUTPUT_DIR=outputs

.env.huggingface

@@ -1,7 +1,9 @@
 # Configurações do Modelo
-MODEL_CACHE_DIR=./.model_cache
-BATCH_SIZE=16
+MODEL_NAME=google/owlv2-base-patch16
 USE_HALF_PRECISION=true
+MAX_WORKERS=2
+TOKENIZERS_PARALLELISM=false
+MODEL_CACHE_DIR=./.model_cache
 DETECTION_CONFIDENCE_THRESHOLD=0.5
 
 # Configurações de Cache

docs/architecture/overview.md

@@ -232,6 +232,7 @@ sequenceDiagram
     Det->>Det: Extrai Frames
     loop Cada Frame
         Det->>Det: Detecta Objetos
+        Det->>Det: Limpa Memória
     end
     Det->>App: Retorna Resultados
     App->>Not: Envia Notificação
@@ -251,7 +252,7 @@ sequenceDiagram
    - Fácil localização de problemas
 
 3. **Escalabilidade**
-   - Novos detectores sem mudanças no core
+   - Processamento frame a frame confiável
    - Múltiplos backends de processamento
    - Sistemas de notificação plugáveis
 
@@ -317,15 +318,18 @@ sequenceDiagram
 
 ### GPU
 
-- Detecção automática de hardware
-- Configurações específicas para T4 e Zero-GPU
-- Gerenciamento de memória otimizado
+- Processamento frame a frame otimizado
+- Memória pinned
+- Async data loading
+- Cache de modelos e frames
+- Gerenciamento eficiente de memória
 
 ### CPU
 
-- Fallback automático
-- Otimizações para processamento em CPU
+- Processamento sequencial otimizado
+- NumPy vectorization
 - Cache de resultados
+- Otimização de memória
 
 ## Diagrama de Componentes
 

docs/faq.md

@@ -5,7 +5,7 @@
 ### Como o sistema funciona?
 
 O sistema utiliza um modelo de IA (OWL-ViT) para detectar objetos de risco em vídeos.
-O processamento pode ser feito em GPU ou CPU, com otimizações específicas para cada caso.
+O processamento é feito frame a frame em GPU ou CPU, com otimizações específicas para cada caso.
 
 ### O que é o OWL-ViT?
 
@@ -41,17 +41,73 @@ O modelo `owlv2-base-patch16-ensemble` apresenta incompatibilidades com processa
 model = model.to(device='cuda', dtype=torch.float16)
 ```
 
-#### Comparação de Versões
-
-1. **Modelo Base**
-   - Mais estável
-   - Menor consumo de memória
-   - Compatível com mais GPUs
-
-2. **Modelo Ensemble**
-   - Maior precisão
-   - Requer mais recursos
-   - Melhor para CPU
+#### Problemas com Batch Processing
+
+O processamento em batch apresenta instabilidades conhecidas:
+
+1. **Erros de Shape**
+   ```
+   ERROR: shape '[4, 21, 512]' is invalid for input of size 44544
+   ERROR: shape '[2, 43, 512]' is invalid for input of size 44544
+   ```
+
+2. **Causas Identificadas**
+   - Inconsistência no padding de imagens em batch
+   - Variações no tamanho dos tensores de entrada
+   - Incompatibilidade com certas configurações de GPU
+
+3. **Solução Recomendada**
+   ```python
+   # Processamento seguro frame a frame
+   batch_size = 1  # Processa um frame por vez
+   ```
+
+4. **Benefícios do Processamento Individual**
+   - Maior estabilidade
+   - Melhor gerenciamento de memória
+   - Resultados mais consistentes
+   - Facilidade de debug
+   - Menor chance de OOM (Out of Memory)
+
+5. **Trade-offs**
+   - Performance levemente reduzida
+   - Processamento mais serializado
+   - Maior tempo total de execução
+
+#### Comparação de Abordagens
+
+| Aspecto | Batch Processing | Frame a Frame |
+|---------|------------------|---------------|
+| Velocidade | Mais rápido (quando funciona) | Mais lento |
+| Estabilidade | Baixa | Alta |
+| Uso de Memória | Alto/Imprevisível | Baixo/Consistente |
+| Confiabilidade | Baixa | Alta |
+| Debug | Difícil | Fácil |
+
+#### Recomendações de Uso
+
+1. **Produção**
+   ```python
+   # Configuração recomendada para produção
+   batch_size = 1
+   resolution = 640
+   fps = 2
+   ```
+
+2. **Desenvolvimento**
+   ```python
+   # Configuração para testes
+   batch_size = 1
+   resolution = 480
+   fps = 1
+   ```
+
+3. **Monitoramento**
+   ```python
+   # Log de progresso a cada 10 frames
+   if i % 10 == 0:
+       logger.info(f"Processados {i}/{len(frames)} frames")
+   ```
 
 ### Como fazer queries efetivas para o OWL-ViT?
 
@@ -129,8 +185,8 @@ pip install torch torchvision --extra-index-url https://download.pytorch.org/whl
 
 **Solução**:
 
-- Reduza o tamanho do batch
-- Diminua a resolução
+- Use processamento frame a frame (padrão)
+- Diminua a resolução se necessário
 - Ajuste `GPU_MEMORY_FRACTION` no `.env`
 
 ## Performance
@@ -139,13 +195,14 @@ pip install torch torchvision --extra-index-url https://download.pytorch.org/whl
 
 #### Ajustes GPU
 
-- Use batch processing
+- Processamento frame a frame otimizado
 - Ative half precision
-- Otimize o cache de modelos
+- Otimize o cache de modelos e frames
+- Gerenciamento eficiente de memória
 
 #### Ajustes CPU
 
-- Ative multiprocessing
+- Processamento sequencial otimizado
 - Use vetorização NumPy
 - Implemente cache de resultados
 
@@ -154,7 +211,7 @@ pip install torch torchvision --extra-index-url https://download.pytorch.org/whl
 ```plaintext
 // Configurações para GPU T4
 GPU_MEMORY_FRACTION=0.9
-BATCH_SIZE=16
+BATCH_SIZE=1  # Processamento frame a frame
 USE_HALF_PRECISION=true
 
 // Configurações para CPU
@@ -163,6 +220,13 @@ CACHE_SIZE=1000
 USE_MULTIPROCESSING=true
 ```
 
+### Sistema de Monitoramento
+
+- Use os logs em `logs/app.log` para acompanhar o processamento frame a frame
+- Monitore GPU com `nvidia-smi`
+- Verifique métricas no Hugging Face
+- Acompanhe logs de progresso a cada 10 frames
+
 ## Deployment
 
 ### Processo de Deploy no Hugging Face

src/domain/detectors/gpu.py

@@ -166,24 +166,19 @@ class WeaponDetectorGPU(BaseDetector):
             # Calcular duração do vídeo
             metrics["video_duration"] = len(frames) / (fps or 2)
             
-            # Processar frames em batch
+            # Processar frames individualmente
             t0 = time.time()
-            batch_size = 1  # Processar um frame por vez para garantir compatibilidade
             detections_by_frame = []
             
             # Pré-alocar tensores para evitar alocações frequentes
             with torch.cuda.device(self.device):
-                torch.cuda.empty_cache()  # Limpar memória antes de começar
+                torch.cuda.empty_cache()
                 
-            for i in range(0, len(frames)):
+            for i, frame in enumerate(frames):
                 try:
-                    # Preparar frame com otimização de memória
-                    frame = frames[i]
-                    if isinstance(frame, np.ndarray):
-                        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                        frame_pil = Image.fromarray(frame_rgb)
-                    else:
-                        frame_pil = frame
+                    # Preparar frame
+                    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    frame_pil = Image.fromarray(frame_rgb)
                     frame_pil = self._preprocess_image(frame_pil)
                     
                     # Processar frame
@@ -206,13 +201,13 @@ class WeaponDetectorGPU(BaseDetector):
                             outputs=outputs,
                             target_sizes=target_sizes,
                             threshold=threshold
-                        )
+                        )[0]
                         
                         # Processar resultados
-                        if len(results[0]["scores"]) > 0:
-                            scores = results[0]["scores"]
-                            boxes = results[0]["boxes"]
-                            labels = results[0]["labels"]
+                        if len(results["scores"]) > 0:
+                            scores = results["scores"]
+                            boxes = results["boxes"]
+                            labels = results["labels"]
                             
                             frame_detections = []
                             for score, box, label in zip(scores, boxes, labels):
@@ -231,7 +226,7 @@ class WeaponDetectorGPU(BaseDetector):
                             if frame_detections:
                                 frame_detections = self._apply_nms(frame_detections)
                                 detections_by_frame.extend(frame_detections)
-                
+                    
                 except Exception as e:
                     logger.error(f"Erro ao processar frame {i}: {str(e)}")
                     continue
@@ -259,28 +254,6 @@ class WeaponDetectorGPU(BaseDetector):
             logger.error(f"Erro ao processar vídeo: {str(e)}")
             return video_path, metrics
 
-    def _validate_batch_shapes(self, batch_inputs: Dict) -> bool:
-        """Valida os shapes dos tensores do batch."""
-        try:
-            pixel_values = batch_inputs.get("pixel_values")
-            if pixel_values is None:
-                return False
-                
-            batch_size = pixel_values.shape[0]
-            if batch_size == 0:
-                return False
-                
-            # Validar dimensões esperadas
-            expected_dims = 4  # [batch_size, channels, height, width]
-            if len(pixel_values.shape) != expected_dims:
-                return False
-                
-            return True
-            
-        except Exception as e:
-            logger.error(f"Erro ao validar shapes do batch: {str(e)}")
-            return False
-
     def _preprocess_image(self, image: Image.Image) -> Image.Image:
         """Pré-processa a imagem para o formato esperado pelo modelo."""
         try: