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

docs/api/interface.md

@@ -22,6 +22,7 @@
 ### Exemplos de Uso
 
 1. **Upload Simples**
+
    ```python
    with gr.Blocks() as demo:
        video_input = gr.Video()
@@ -30,6 +31,7 @@
    ```
 
 2. **Configurações Avançadas**
+
    ```python
    with gr.Blocks() as demo:
        with gr.Row():
@@ -42,6 +44,7 @@
 ### Endpoints
 
 #### 1. Detecção em Vídeo
+
 ```http
 POST /api/detect
 Content-Type: multipart/form-data
@@ -54,6 +57,7 @@ Content-Type: multipart/form-data
 ```
 
 **Resposta:**
+
 ```json
 {
     "detections": [
@@ -78,6 +82,7 @@ Content-Type: multipart/form-data
 ```
 
 #### 2. Status do Serviço
+
 ```http
 GET /api/status
 
@@ -106,6 +111,7 @@ Response:
 ## Webhooks
 
 ### Configuração
+
 ```http
 POST /api/webhooks/configure
 {
@@ -116,6 +122,7 @@ POST /api/webhooks/configure
 ```
 
 ### Formato do Callback
+
 ```json
 {
     "event": "detection",
@@ -131,6 +138,7 @@ POST /api/webhooks/configure
 ## Integração com Outros Serviços
 
 ### 1. Hugging Face
+
 ```python
 from huggingface_hub import HfApi
 
@@ -143,6 +151,7 @@ api.upload_file(
 ```
 
 ### 2. Sistemas de Notificação
+
 ```python
 def notify(detection):
     requests.post(
@@ -164,4 +173,4 @@ def notify(detection):
 3. **Validação de Entrada**
    - Tamanho máximo
    - Formatos permitidos
-   - Sanitização 
+   - Sanitização

docs/architecture/overview.md

@@ -4,6 +4,209 @@
 
 O sistema de detecção de riscos em vídeo é construído seguindo os princípios da Clean Architecture, garantindo separação de responsabilidades e facilitando a manutenção e evolução do código.
 
+## Modelo de IA: OWL-ViT
+
+O OWL-ViT (Vision Transformer for Open-World Localization) é um modelo de visão computacional avançado que combina:
+
+- Transformers para processamento de imagens
+- Zero-shot learning para detecção de objetos
+- Queries em linguagem natural para especificar alvos
+
+### Considerações Técnicas
+
+#### Versões do Modelo
+
+1. **OWL-ViT Base (Atual)**
+
+   ```python
+   model_name = "google/owlv2-base-patch16"
+   ```
+
+   - Compatível com GPU T4
+   - Otimizado para inference
+   - Suporte a half precision
+
+2. **OWL-ViT Ensemble (Descontinuado)**
+
+   ```python
+   model_name = "google/owlv2-base-patch16-ensemble"
+   ```
+
+   - Problemas de compatibilidade GPU
+   - Requer branch dev do Transformers
+   - Maior precisão, mas instável
+
+#### Requisitos Específicos
+
+```python
+# Configurações necessárias para GPU
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.benchmark = True
+model = model.half()  # Usar FP16
+
+# Branch específico do Transformers
+# pip install git+https://github.com/huggingface/transformers.git
+```
+
+### Como Funciona
+
+1. **Processamento de Imagem**
+   - Divide a imagem em patches
+   - Processa usando arquitetura Transformer
+   - Gera representações visuais ricas
+
+2. **Sistema de Queries**
+   - Aceita descrições em texto natural
+   - Exemplos de queries efetivas:
+
+     ```python
+     queries = [
+         "uma arma de fogo",
+         "uma pistola",
+         "um rifle",
+         "uma faca",
+         "um objeto pontiagudo perigoso"
+     ]
+     ```
+
+3. **Detecção Zero-shot**
+   - Não requer treinamento específico
+   - Adapta-se a novos objetos
+   - Alta precisão em tempo real
+
+## Clean Architecture
+
+### Camadas
+
+```mermaid
+graph TD
+    A[Presentation] --> B[Application]
+    B --> C[Domain]
+    D[Infrastructure] --> B
+    D --> C
+```
+
+1. **Domain (Núcleo)**
+   - Regras de negócio
+   - Entidades fundamentais
+   - Interfaces abstratas
+
+2. **Application**
+   - Casos de uso
+   - Orquestração
+   - Lógica de aplicação
+
+3. **Infrastructure**
+   - Implementações concretas
+   - Integrações externas
+   - Adaptadores
+
+4. **Presentation**
+   - Interface Gradio
+   - APIs REST
+   - Webhooks
+
+### Diagrama de Classes
+
+```mermaid
+classDiagram
+    class DetectorInterface {
+        <<interface>>
+        +process_video()
+        +detect_objects()
+        +clean_memory()
+    }
+    
+    class WeaponDetectorGPU {
+        -model: OWLViT
+        +process_video()
+        +detect_objects()
+    }
+    
+    class WeaponDetectorCPU {
+        -model: OWLViT
+        +process_video()
+        +detect_objects()
+    }
+    
+    class NotificationService {
+        <<interface>>
+        +send_notification()
+    }
+    
+    DetectorInterface <|-- WeaponDetectorGPU
+    DetectorInterface <|-- WeaponDetectorCPU
+    NotificationService <|-- EmailNotification
+    NotificationService <|-- TelegramNotification
+```
+
+## Extensibilidade
+
+### 1. Novos Modelos de IA
+
+```python
+class NewDetector(DetectorInterface):
+    """Implementação de novo detector."""
+    def process_video(self):
+        # Implementação específica
+        pass
+```
+
+### 2. Suporte a Hardware
+
+- Abstração de hardware via interfaces
+- Fácil adição de novos backends:
+  - TPU
+  - Neural Engine
+  - Outros aceleradores
+
+### 3. Sistema de Notificações
+
+```python
+class NewNotificationService(NotificationService):
+    """Novo serviço de notificação."""
+    def send_notification(self):
+        # Implementação específica
+        pass
+```
+
+## Fluxo de Processamento
+
+```mermaid
+sequenceDiagram
+    participant UI as Interface
+    participant App as Application
+    participant Det as Detector
+    participant Not as Notification
+    
+    UI->>App: Upload Vídeo
+    App->>Det: Processa Vídeo
+    Det->>Det: Extrai Frames
+    loop Cada Frame
+        Det->>Det: Detecta Objetos
+    end
+    Det->>App: Retorna Resultados
+    App->>Not: Envia Notificação
+    App->>UI: Atualiza Interface
+```
+
+## Benefícios da Arquitetura
+
+1. **Desacoplamento**
+   - Mudanças em uma camada não afetam outras
+   - Facilita testes unitários
+   - Permite evolução independente
+
+2. **Manutenibilidade**
+   - Código organizado e previsível
+   - Responsabilidades bem definidas
+   - Fácil localização de problemas
+
+3. **Escalabilidade**
+   - Novos detectores sem mudanças no core
+   - Múltiplos backends de processamento
+   - Sistemas de notificação plugáveis
+
 ## Camadas da Arquitetura
 
 ### 1. Domain (Núcleo)
@@ -104,4 +307,4 @@ graph TD
 ### 3. Open/Closed
 
 - Extensível para novos detectores
-- Fácil adição de novos serviços 
+- Fácil adição de novos serviços

docs/development/contributing.md

@@ -12,12 +12,14 @@
      - Python Test Explorer
 
 2. **Configuração do Git**
+
    ```bash
    git config --global user.name "Seu Nome"
    git config --global user.email "[email protected]"
    ```
 
 3. **Pre-commit Hooks**
+
    ```bash
    pip install pre-commit
    pre-commit install
@@ -26,12 +28,14 @@
 ## Padrões de Código
 
 ### 1. Estilo
+
 - PEP 8
 - Máximo 88 caracteres por linha
 - Docstrings em todas as funções/classes
 - Type hints obrigatórios
 
 Exemplo:
+
 ```python
 def process_frame(
     frame: np.ndarray,
@@ -50,7 +54,8 @@ def process_frame(
 ```
 
 ### 2. Estrutura de Arquivos
-```
+
+```md
 src/
 ├── domain/
 │   ├── entities/
@@ -66,11 +71,13 @@ src/
 ```
 
 ### 3. Testes
+
 - pytest para testes unitários
 - pytest-cov para cobertura
 - Mocking para dependências externas
 
 Exemplo:
+
 ```python
 def test_process_frame():
     detector = WeaponDetector()
@@ -82,23 +89,15 @@ def test_process_frame():
 ## Fluxo de Trabalho
 
 ### 1. Branches
+
 - `main`: Produção
 - `develop`: Desenvolvimento
 - `feature/*`: Novas funcionalidades
 - `fix/*`: Correções
 - `release/*`: Preparação de release
 
-### 2. Commits
-```
-feat: Adiciona detecção em tempo real
-^--^  ^------------------------^
-|     |
-|     +-> Descrição no presente
-|
-+-------> Tipo: feat, fix, docs, style, refactor
-```
+### 2. Pull Requests
 
-### 3. Pull Requests
 - Template obrigatório
 - Code review necessário
 - CI deve passar
@@ -107,6 +106,7 @@ feat: Adiciona detecção em tempo real
 ## CI/CD
 
 ### GitHub Actions
+
 ```yaml
 name: CI
 
@@ -130,12 +130,15 @@ jobs:
 ```
 
 ### Deploy
+
 1. Staging
+
    ```bash
    ./deploy.sh staging
    ```
 
 2. Produção
+
    ```bash
    ./deploy.sh production
    ```
@@ -143,6 +146,7 @@ jobs:
 ## Debugging
 
 ### 1. Logs
+
 ```python
 import logging
 
@@ -151,6 +155,7 @@ logger.info("Processando frame %d", frame_number)
 ```
 
 ### 2. Profiling
+
 ```python
 import cProfile
 
@@ -163,6 +168,7 @@ def profile_detection():
 ```
 
 ### 3. GPU Monitoring
+
 ```python
 import torch
 
@@ -173,11 +179,13 @@ def check_gpu():
 ## Otimizações
 
 ### 1. GPU
+
 - Batch processing
 - Memória pinned
 - Async data loading
 
 ### 2. CPU
+
 - Multiprocessing
 - NumPy vectorization
 - Cache de resultados
@@ -185,11 +193,13 @@ def check_gpu():
 ## Segurança
 
 ### 1. Dependências
+
 - Safety check
 - Dependabot
 - SAST scanning
 
 ### 2. Código
+
 - Input validation
 - Error handling
 - Secrets management
@@ -197,6 +207,7 @@ def check_gpu():
 ## Documentação
 
 ### 1. Docstrings
+
 ```python
 def detect_objects(
     self,
@@ -217,12 +228,14 @@ def detect_objects(
 ```
 
 ### 2. Sphinx
+
 ```bash
 cd docs
 make html
 ```
 
 ### 3. README
+
 - Badges atualizados
 - Exemplos práticos
-- Troubleshooting comum 
+- Troubleshooting comum

docs/development/development.md

@@ -199,4 +199,4 @@ def profile_detection():
 - Multiprocessing
 - NumPy vectorization
 - Cache de resultados
-- Otimização de memória 
+- Otimização de memória

docs/faq.md

@@ -7,7 +7,74 @@
 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.
 
-### Quais objetos são detectados?
+### O que é o OWL-ViT?
+
+O OWL-ViT (Vision Transformer for Open-World Localization) é um modelo de IA que:
+
+- Usa arquitetura Transformer para processar imagens
+- Permite detecção zero-shot de objetos
+- Aceita queries em linguagem natural
+- Não precisa de treinamento específico para novos objetos
+
+### Problemas Conhecidos com OWL-ViT
+
+#### Limitações do Modelo Ensemble
+
+O modelo `owlv2-base-patch16-ensemble` apresenta incompatibilidades com processamento GPU:
+
+- Conflitos com versões estáveis do Transformers
+- Problemas de memória em GPUs com menos de 16GB
+- Instabilidade em batch processing
+
+**Solução Implementada:**
+
+1. Mudança para modelo base: `owlv2-base-patch16`
+2. Atualização do Transformers para branch de desenvolvimento:
+
+    ```bash
+    pip install git+https://github.com/huggingface/transformers.git
+    ```
+
+3. Ajustes nas configurações de memória GPU:
+
+```python
+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
+
+### Como fazer queries efetivas para o OWL-ViT?
+
+Para melhores resultados, use estas técnicas:
+
+1. **Seja Específico**
+   - Bom: "uma pistola preta"
+   - Ruim: "arma"
+
+2. **Use Variações**
+   - "uma arma de fogo"
+   - "uma pistola"
+   - "um revólver"
+
+3. **Inclua Contexto**
+   - "uma faca na mão de alguém"
+   - "uma arma apontada"
+
+4. **Descreva Características**
+   - "uma faca com lâmina metálica"
+   - "um rifle com coronha"
+
+### Tipos de Objetos Detectados
 
 #### Armas de Fogo
 
@@ -31,13 +98,13 @@ O processamento pode ser feito em GPU ou CPU, com otimizações específicas par
 
 ### Requisitos de Hardware
 
-#### GPU
+#### Especificações GPU
 
 - NVIDIA T4 16GB (recomendado)
 - CUDA 11.8+
 - 16GB RAM
 
-#### CPU
+#### Especificações CPU
 
 - 8+ cores
 - 32GB RAM
@@ -68,15 +135,15 @@ pip install torch torchvision --extra-index-url https://download.pytorch.org/whl
 
 ## Performance
 
-### Como melhorar a performance?
+### Otimizações de Sistema
 
-#### GPU
+#### Ajustes GPU
 
 - Use batch processing
 - Ative half precision
 - Otimize o cache de modelos
 
-#### CPU
+#### Ajustes CPU
 
 - Ative multiprocessing
 - Use vetorização NumPy
@@ -85,12 +152,12 @@ pip install torch torchvision --extra-index-url https://download.pytorch.org/whl
 ### Configurações Recomendadas
 
 ```plaintext
-# GPU T4
+// Configurações para GPU T4
 GPU_MEMORY_FRACTION=0.9
 BATCH_SIZE=16
 USE_HALF_PRECISION=true
 
-# CPU
+// Configurações para CPU
 MAX_WORKERS=8
 CACHE_SIZE=1000
 USE_MULTIPROCESSING=true
@@ -98,7 +165,7 @@ USE_MULTIPROCESSING=true
 
 ## Deployment
 
-### Como fazer deploy no Hugging Face?
+### Processo de Deploy no Hugging Face
 
 1. Configure as credenciais:
 
@@ -119,7 +186,7 @@ USE_MULTIPROCESSING=true
     ./deploy.sh
     ```
 
-### Monitoramento
+### Sistema de Monitoramento
 
 - Use os logs em `logs/app.log`
 - Monitore GPU com `nvidia-smi`
@@ -127,7 +194,7 @@ USE_MULTIPROCESSING=true
 
 ## Segurança
 
-### Como proteger as credenciais?
+### Gerenciamento de Credenciais
 
 1. Use variáveis de ambiente:
 
@@ -142,4 +209,24 @@ USE_MULTIPROCESSING=true
 
 - Limite o tamanho dos vídeos
 - Verifique formatos permitidos
-- Sanitize inputs 
+- Sanitize inputs
+
+```text
+HUGGINGFACE_TOKEN=seu_token
+GPU_MEMORY_FRACTION=0.9
+MAX_CONCURRENT_REQUESTS=2
+```
+
+```text
+USE_GPU=true
+GPU_DEVICE=0
+```
+
+```text
+USE_GPU=false
+```
+
+```text
+HF_SPACE_ID=seu-espaco
+HF_TOKEN=seu_token
+```

docs/scenarios.md

@@ -0,0 +1,219 @@
+# Cenários e Casos de Uso
+
+## Cenários de Produção
+
+### Alta Demanda
+
+#### Múltiplas Requisições
+
+- Sistema de fila com priorização
+- Balanceamento GPU/CPU automático
+- Cache inteligente de resultados
+
+```python
+# Exemplo de configuração de fila
+demo = demo.queue(
+    api_open=False,
+    max_size=10,
+    concurrency_count=2
+)
+```
+
+#### Processamento em Lote
+
+- Agendamento de análises
+- Otimização de recursos
+- Relatórios consolidados
+
+### Recuperação e Resiliência
+
+#### Tratamento de Falhas
+
+```python
+try:
+    result = detector.process_video(video_path)
+except GPUOutOfMemoryError:
+    # Fallback para CPU
+    result = cpu_detector.process_video(video_path)
+except NetworkError:
+    # Retry com backoff exponencial
+    result = retry_with_backoff(process_video, video_path)
+```
+
+#### Persistência de Estado
+
+- Checkpoints de processamento
+- Retomada após falhas
+- Backup de configurações
+
+## Cenários de Integração
+
+### Sistemas de Vigilância
+
+#### CCTV e Câmeras IP
+
+```python
+# Exemplo de integração com RTSP
+stream_url = "rtsp://camera.local/stream1"
+detector.process_stream(stream_url)
+```
+
+#### Sistemas Legados
+
+- Suporte a formatos antigos
+- APIs de compatibilidade
+- Conversão de protocolos
+
+### Compliance e Segurança
+
+#### LGPD/GDPR
+
+- Retenção configurável de dados
+- Anonimização automática
+- Logs de auditoria detalhados
+
+```python
+# Exemplo de política de retenção
+retention_policy = {
+    "video_data": "7d",
+    "detection_logs": "30d",
+    "audit_logs": "365d"
+}
+```
+
+#### Segurança
+
+- TLS/SSL para todas as conexões
+- Autenticação JWT
+- Rate limiting por IP/usuário
+
+## Limitações e Contornos
+
+### Detecção
+
+#### Falsos Positivos
+
+- Objetos similares (ex: guarda-chuvas vs. armas)
+- Condições de baixa luminosidade
+- Ângulos desfavoráveis
+
+**Soluções:**
+
+```python
+# Ajuste de confiança por contexto
+if low_light_condition:
+    threshold = 0.7  # Mais restritivo
+else:
+    threshold = 0.5  # Padrão
+```
+
+#### Falsos Negativos
+
+- Objetos parcialmente visíveis
+- Movimento rápido
+- Oclusões
+
+**Mitigações:**
+
+- Processamento de múltiplos frames
+- Análise de sequência temporal
+- Fusão de detecções
+
+### Performance
+
+#### Gargalos Conhecidos
+
+1. **Vídeos Longos**
+
+   ```python
+   # Processamento em chunks
+   chunk_size = 60  # segundos
+   for chunk in video.split_chunks(chunk_size):
+       process_chunk(chunk)
+   ```
+
+2. **Alta Resolução**
+   - Downscaling automático
+   - Processamento em tiles
+   - Balanceamento qualidade/performance
+
+#### Limites do Sistema
+
+| Recurso | Limite | Observação |
+|---------|--------|------------|
+| Vídeo | 100MB | Por upload |
+| Duração | 5min | Por análise |
+| Usuários | 10 | Simultâneos |
+
+## Melhores Práticas
+
+### Preparação de Dados
+
+#### Vídeos
+
+- Compressão H.264/H.265
+- Resolução máxima 1080p
+- FPS entre 24-30
+
+```bash
+# Exemplo de otimização com ffmpeg
+ffmpeg -i input.mp4 -c:v libx264 -crf 23 -preset medium output.mp4
+```
+
+#### Formato Ideal
+
+- Codec: H.264
+- Container: MP4
+- Bitrate: 2-5 Mbps
+
+### Monitoramento
+
+#### Métricas Críticas
+
+```python
+metrics = {
+    "detection_rate": detections/total_frames,
+    "processing_time": end_time - start_time,
+    "gpu_utilization": gpu_util
+}
+```
+
+#### Sistema de Alertas
+
+- Thresholds configuráveis
+- Notificações em tempo real
+- Ações automáticas
+
+### Backup e DR
+
+#### Estratégia
+
+1. Backup incremental de dados
+2. Snapshot diário de configurações
+3. Replicação de logs
+
+#### Recuperação
+
+1. Restore automatizado
+2. Testes periódicos
+3. Documentação detalhada
+
+## Expansão Futura
+
+### Novos Modelos
+
+- Integração plug-and-play
+- Versionamento de modelos
+- A/B testing
+
+### Novas Plataformas
+
+- Suporte a TPU
+- Apple Neural Engine
+- Edge devices
+
+### Novos Casos de Uso
+
+- Análise comportamental
+- Detecção de anomalias
+- Rastreamento de objetos

docs/setup/installation.md

@@ -3,12 +3,14 @@
 ## Requisitos do Sistema
 
 ### Hardware Recomendado
-- **GPU**: NVIDIA T4 16GB ou superior
-- **CPU**: 4+ cores
-- **RAM**: 16GB mínimo
+
+- **Processador**: NVIDIA T4 16GB ou superior
+- **Processamento**: 4+ cores
+- **Memória**: 16GB mínimo
 - **Armazenamento**: 10GB+ disponível
 
 ### Software Necessário
+
 - Python 3.10+
 - CUDA 11.8+ (para GPU)
 - Git
@@ -16,30 +18,35 @@
 ## Instalação Local
 
 1. Clone o repositório:
-```bash
-git clone https://github.com/seu-usuario/hackatoon-1iadt.git
-cd hackatoon-1iadt
-```
+
+   ```bash
+   git clone https://github.com/seu-usuario/hackatoon-1iadt.git
+   cd hackatoon-1iadt
+   ```
 
 2. Crie e ative um ambiente virtual:
-```bash
-python -m venv venv
-source venv/bin/activate  # Linux/Mac
-.\venv\Scripts\activate   # Windows
-```
+
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # Linux/Mac
+   .\venv\Scripts\activate   # Windows
+   ```
 
 3. Instale as dependências:
-```bash
-pip install -r requirements.txt
-```
+
+   ```bash
+   pip install -r requirements.txt
+   ```
 
 4. Configure as variáveis de ambiente:
-```bash
-cp .env.example .env
-```
+
+   ```bash
+   cp .env.example .env
+   ```
 
 Edite o arquivo `.env` com suas configurações:
-```
+
+```plaintext
 HUGGINGFACE_TOKEN=seu_token
 GPU_MEMORY_FRACTION=0.9
 MAX_CONCURRENT_REQUESTS=2
@@ -47,57 +54,67 @@ MAX_CONCURRENT_REQUESTS=2
 
 ## Configuração do Ambiente
 
-### GPU (NVIDIA)
+### Configuração NVIDIA
 
 1. Verifique a instalação do CUDA:
-```bash
-nvidia-smi
-```
+
+   ```bash
+   nvidia-smi
+   ```
 
 2. Ajuste as configurações de GPU em `.env`:
-```
-USE_GPU=true
-GPU_DEVICE=0
-```
 
-### CPU
+   ```plaintext
+   USE_GPU=true
+   GPU_DEVICE=0
+   ```
+
+### Modo CPU
 
 Para usar apenas CPU:
-```
+
+```plaintext
 USE_GPU=false
 ```
 
-## Deployment no Hugging Face
+## Processo de Deploy
 
-1. Configure as variáveis de ambiente do Hugging Face:
-```bash
-cp .env.example .env.huggingface
-```
+### Deploy no Hugging Face
+
+1. Configure as variáveis de ambiente:
+
+   ```bash
+   cp .env.example .env.huggingface
+   ```
 
 2. Edite `.env.huggingface`:
-```
-HF_SPACE_ID=seu-espaco
-HF_TOKEN=seu_token
-```
+
+   ```plaintext
+   HF_SPACE_ID=seu-espaco
+   HF_TOKEN=seu_token
+   ```
 
 3. Execute o deploy:
-```bash
-./deploy.sh
-```
+
+   ```bash
+   ./deploy.sh
+   ```
 
 ## Verificação da Instalação
 
 1. Execute os testes:
-```bash
-pytest
-```
+
+   ```bash
+   pytest
+   ```
 
 2. Inicie a aplicação:
-```bash
-python app.py
-```
 
-3. Acesse: http://localhost:7860
+   ```bash
+   python app.py
+   ```
+
+3. Acesse: <http://localhost:7860>
 
 ## Troubleshooting
 
@@ -115,7 +132,7 @@ python app.py
    - Verifique credenciais do Hugging Face
    - Confirme permissões do espaço
 
-### Logs
+### Sistema de Logs
 
 - Logs da aplicação: `logs/app.log`
 - Logs do GPU: `logs/gpu.log`
@@ -123,6 +140,7 @@ python app.py
 ## Suporte
 
 Para problemas e dúvidas:
+
 1. Abra uma issue no GitHub
 2. Consulte a documentação completa
-3. Entre em contato com a equipe de suporte 
+3. Entre em contato com a equipe de suporte

src/main.py

@@ -135,7 +135,7 @@ def main():
                 api_open=False,
                 max_size=queue_size,
                 status_update_rate="auto",
-                concurrency_count=max_concurrent
+                default_concurrency_limit=max_concurrent
             )
             
             # Launch