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

README.md

@@ -14,98 +14,143 @@ resources:
   gpu: true
 ---
 
-# Sistema de Detecção de Riscos em Vídeo
+# Detector de Riscos em Vídeo
 
-Este projeto implementa um sistema de detecção de riscos em vídeo utilizando YOLOv8 e Clean Architecture.
+Sistema de detecção de objetos de risco em vídeos usando OWL-ViT e processamento GPU/CPU otimizado.
 
-## Pré-requisitos
+[![Open in Hugging Face](https://img.shields.io/badge/Hugging%20Face-Spaces-yellow)](https://huggingface.co/spaces/seu-usuario/seu-espaco)
+[![GitHub](https://img.shields.io/badge/GitHub-Repo-blue)](https://github.com/seu-usuario/hackatoon-1iadt)
 
-- Python 3.9 ou superior
-- pip (gerenciador de pacotes Python)
-- Ambiente virtual Python (recomendado)
+## 🚀 Funcionalidades
 
-## Configuração do Ambiente
+- Detecção de objetos de risco em vídeos
+- Processamento otimizado em GPU (NVIDIA T4) e CPU
+- Interface web intuitiva com Gradio
+- API REST para integração
+- Suporte a webhooks para notificações
+- Métricas detalhadas de processamento
+
+## 📋 Requisitos
+
+- Python 3.10+
+- CUDA 11.8+ (para GPU)
+- NVIDIA T4 16GB ou superior (recomendado)
+- 16GB RAM mínimo
+
+## 🔧 Instalação
 
 1. Clone o repositório:
 ```bash
-git clone [URL_DO_REPOSITORIO]
-cd [NOME_DO_DIRETORIO]
+git clone https://github.com/seu-usuario/hackatoon-1iadt.git
+cd hackatoon-1iadt
 ```
 
-2. Crie e ative um ambiente virtual:
+2. Instale as dependências:
 ```bash
-python -m venv .venv
-source .venv/bin/activate  # Linux/Mac
-# OU
-.venv\Scripts\activate  # Windows
+pip install -r requirements.txt
 ```
 
-3. Instale as dependências:
+3. Configure o ambiente:
 ```bash
-pip install -r requirements.txt
+cp .env.example .env
 ```
 
-4. Configure as variáveis de ambiente:
-Crie um arquivo `.env` na raiz do projeto com as seguintes variáveis:
+[Documentação completa de instalação](docs/setup/installation.md)
+
+## 💻 Uso
+
+1. Inicie a aplicação:
+```bash
+python app.py
+```
+
+2. Acesse: http://localhost:7860
+
+3. Upload de vídeo:
+   - Arraste ou selecione um vídeo
+   - Ajuste as configurações
+   - Clique em "Detectar"
+
+## 📚 Documentação
+
+- [Arquitetura do Sistema](docs/architecture/overview.md)
+- [Instalação e Configuração](docs/setup/installation.md)
+- [API e Interface](docs/api/interface.md)
+
+## 🏗️ Arquitetura
+
+O projeto segue os princípios da Clean Architecture:
+
 ```
-NOTIFICATION_API_KEY=sua_chave_api
+src/
+├── domain/         # Regras de negócio
+├── application/    # Casos de uso
+├── infrastructure/ # Implementações
+└── presentation/   # Interface
 ```
 
-## Executando o Projeto
+[Detalhes da arquitetura](docs/architecture/overview.md)
 
-1. Ative o ambiente virtual (se ainda não estiver ativo)
+## 🚀 Deploy no Hugging Face
 
-2. Execute o aplicativo:
+1. Configure as credenciais:
 ```bash
-python src/main.py
+cp .env.example .env.huggingface
 ```
 
-3. Acesse a interface web através do navegador no endereço mostrado no terminal (geralmente http://localhost:7860)
+2. Execute o deploy:
+```bash
+./deploy.sh
+```
 
-## Funcionalidades
+[Instruções detalhadas de deploy](docs/setup/installation.md#deployment-no-hugging-face)
 
-- Upload de vídeos para análise
-- Detecção de objetos em tempo real
-- Configuração de parâmetros de detecção
-- Sistema de notificações
-- Monitoramento de recursos do sistema
+## 💪 Máquinas Recomendadas
 
-## Estrutura do Projeto
+### GPU
+- NVIDIA T4 16GB (Hugging Face Pro)
+- NVIDIA A100 (Performance máxima)
+- NVIDIA V100 (Alternativa)
 
-O projeto segue os princípios da Clean Architecture:
+### CPU
+- 8+ cores
+- 32GB+ RAM
+- SSD para armazenamento
 
-- `domain/`: Regras de negócio e entidades
-- `application/`: Casos de uso e interfaces
-- `infrastructure/`: Implementações concretas
-- `presentation/`: Interface com usuário (Gradio)
+## 🔍 Interface
 
-## Contribuindo
+### Componentes
+- Upload de vídeo (MP4, AVI, MOV)
+- Configurações de detecção
+- Visualização de resultados
+- Métricas em tempo real
 
-1. Fork o projeto
-2. Crie uma branch para sua feature (`git checkout -b feature/AmazingFeature`)
-3. Commit suas mudanças (`git commit -m 'Add some AmazingFeature'`)
-4. Push para a branch (`git push origin feature/AmazingFeature`)
-5. Abra um Pull Request
+[Documentação da interface](docs/api/interface.md)
+
+## 🔗 Links
 
-## Tecnologias
+- [Hugging Face Space](https://huggingface.co/spaces/seu-usuario/seu-espaco)
+- [GitHub Repository](https://github.com/seu-usuario/hackatoon-1iadt)
+- [Documentação](docs/)
+- [Issues](https://github.com/seu-usuario/hackatoon-1iadt/issues)
 
-- Python 3.8+
-- PyTorch com CUDA
-- OWL-ViT
-- Gradio
-- FFmpeg
+## 📄 Licença
 
-## Requisitos de Hardware
+Este projeto está licenciado sob a MIT License - veja o arquivo [LICENSE](LICENSE) para detalhes.
 
-- GPU NVIDIA T4 (fornecida pelo Hugging Face)
-- 16GB de RAM
-- Armazenamento para cache de modelos
+## 👥 Contribuição
+
+1. Fork o projeto
+2. Crie sua feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit suas mudanças (`git commit -m 'Add some AmazingFeature'`)
+4. Push para a branch (`git push origin feature/AmazingFeature`)
+5. Abra um Pull Request
 
-## Limitações
+## 📞 Suporte
 
-- Processamento pode ser lento em CPUs menos potentes
-- Requer GPU para melhor performance
-- Alguns falsos positivos em condições de baixa luz
+- Abra uma [issue](https://github.com/seu-usuario/hackatoon-1iadt/issues)
+- Consulte a [documentação](docs/)
+- Entre em contato com a equipe
 
 ---
 Desenvolvido com ❤️ para o Hackathon FIAP

docs/api/interface.md

@@ -0,0 +1,167 @@
+# Interface e API
+
+## Interface Web (Gradio)
+
+### Componentes Principais
+
+1. **Upload de Vídeo**
+   - Formatos suportados: MP4, AVI, MOV
+   - Tamanho máximo: 100MB
+   - Duração máxima: 5 minutos
+
+2. **Configurações de Detecção**
+   - Limiar de confiança (0-100%)
+   - Modo de processamento (GPU/CPU)
+   - Tamanho do lote de frames
+
+3. **Visualização de Resultados**
+   - Vídeo com anotações
+   - Timeline de detecções
+   - Métricas de processamento
+
+### Exemplos de Uso
+
+1. **Upload Simples**
+   ```python
+   with gr.Blocks() as demo:
+       video_input = gr.Video()
+       detect_btn = gr.Button("Detectar")
+       output_display = gr.Video()
+   ```
+
+2. **Configurações Avançadas**
+   ```python
+   with gr.Blocks() as demo:
+       with gr.Row():
+           confidence = gr.Slider(0, 100)
+           batch_size = gr.Number(value=4)
+   ```
+
+## API REST
+
+### Endpoints
+
+#### 1. Detecção em Vídeo
+```http
+POST /api/detect
+Content-Type: multipart/form-data
+
+{
+    "video": binary_data,
+    "confidence": 0.5,
+    "use_gpu": true
+}
+```
+
+**Resposta:**
+```json
+{
+    "detections": [
+        {
+            "frame": 0,
+            "timestamp": "00:00:01",
+            "objects": [
+                {
+                    "label": "arma",
+                    "confidence": 95.5,
+                    "bbox": [x1, y1, x2, y2]
+                }
+            ]
+        }
+    ],
+    "metrics": {
+        "frames_processed": 150,
+        "processing_time": 2.5,
+        "fps": 60
+    }
+}
+```
+
+#### 2. Status do Serviço
+```http
+GET /api/status
+
+Response:
+{
+    "status": "online",
+    "gpu_available": true,
+    "memory_usage": "45%",
+    "queue_size": 2
+}
+```
+
+### Códigos de Erro
+
+- `400`: Parâmetros inválidos
+- `413`: Vídeo muito grande
+- `500`: Erro interno
+- `503`: Serviço indisponível
+
+### Rate Limiting
+
+- 10 requisições/minuto por IP
+- 100 requisições/hora por usuário
+- Tamanho máximo do vídeo: 100MB
+
+## Webhooks
+
+### Configuração
+```http
+POST /api/webhooks/configure
+{
+    "url": "https://seu-servidor.com/callback",
+    "events": ["detection", "error"],
+    "secret": "seu_secret"
+}
+```
+
+### Formato do Callback
+```json
+{
+    "event": "detection",
+    "timestamp": "2024-03-20T15:30:00Z",
+    "data": {
+        "video_id": "abc123",
+        "detections": []
+    },
+    "signature": "hash_hmac"
+}
+```
+
+## Integração com Outros Serviços
+
+### 1. Hugging Face
+```python
+from huggingface_hub import HfApi
+
+api = HfApi()
+api.upload_file(
+    path_or_fileobj="./video.mp4",
+    path_in_repo="videos/test.mp4",
+    repo_id="seu-espaco"
+)
+```
+
+### 2. Sistemas de Notificação
+```python
+def notify(detection):
+    requests.post(
+        "https://seu-servidor.com/notify",
+        json={"detection": detection}
+    )
+```
+
+## Considerações de Segurança
+
+1. **Autenticação**
+   - Token JWT obrigatório
+   - Renovação automática
+
+2. **Rate Limiting**
+   - Por IP e usuário
+   - Cooldown progressivo
+
+3. **Validação de Entrada**
+   - Tamanho máximo
+   - Formatos permitidos
+   - Sanitização 

docs/architecture/overview.md

@@ -0,0 +1,94 @@
+# Arquitetura do Sistema
+
+## Visão Geral
+
+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.
+
+## Camadas da Arquitetura
+
+### 1. Domain (Núcleo)
+- Contém as regras de negócio e entidades fundamentais
+- Independente de frameworks e bibliotecas externas
+- Localização: `src/domain/`
+
+#### Componentes Principais:
+- `detectors/`: Implementações dos detectores (GPU/CPU)
+- `entities/`: Objetos de domínio
+- `factories/`: Fábricas para criação de objetos
+- `interfaces/`: Contratos e interfaces
+
+### 2. Application
+- Implementa os casos de uso da aplicação
+- Orquestra o fluxo de dados entre as camadas
+- Localização: `src/application/`
+
+#### Casos de Uso:
+- `process_video`: Processamento e análise de vídeos
+- Notificações de detecções
+- Gerenciamento de cache
+
+### 3. Infrastructure
+- Implementações concretas de interfaces
+- Integrações com serviços externos
+- Localização: `src/infrastructure/`
+
+#### Serviços:
+- `WeaponDetectorService`: Serviço principal de detecção
+- `NotificationService`: Serviço de notificações
+- Gerenciamento de GPU/CPU
+
+### 4. Presentation
+- Interface com usuário via Gradio
+- Localização: `src/presentation/`
+
+#### Componentes:
+- Interface web responsiva
+- Configurações de processamento
+- Visualização de resultados
+
+## Fluxo de Dados
+
+1. Upload do vídeo via interface Gradio
+2. Processamento pelo caso de uso
+3. Detecção de objetos usando GPU/CPU
+4. Notificações (se configuradas)
+5. Retorno dos resultados
+
+## Otimizações
+
+### GPU
+- Detecção automática de hardware
+- Configurações específicas para T4 e Zero-GPU
+- Gerenciamento de memória otimizado
+
+### CPU
+- Fallback automático
+- Otimizações para processamento em CPU
+- Cache de resultados
+
+## Diagrama de Componentes
+
+```mermaid
+graph TD
+    A[Interface Web] --> B[Casos de Uso]
+    B --> C[Detector Service]
+    C --> D[GPU Detector]
+    C --> E[CPU Detector]
+    B --> F[Notification Service]
+    D --> G[OWL-ViT Model]
+    E --> G
+```
+
+## Considerações de Design
+
+1. **Inversão de Dependência**
+   - Interfaces abstratas no domínio
+   - Implementações concretas na infraestrutura
+
+2. **Single Responsibility**
+   - Cada componente com responsabilidade única
+   - Separação clara de concerns
+
+3. **Open/Closed**
+   - Extensível para novos detectores
+   - Fácil adição de novos serviços 

docs/development/contributing.md

@@ -0,0 +1,228 @@
+# Guia de Desenvolvimento
+
+## Ambiente de Desenvolvimento
+
+### Setup Inicial
+
+1. **IDE Recomendada**
+   - VSCode com extensões:
+     - Python
+     - Pylance
+     - GitLens
+     - 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
+   ```
+
+## 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,
+    confidence: float = 0.5
+) -> List[Detection]:
+    """Processa um frame para detecção de objetos.
+
+    Args:
+        frame: Array numpy do frame
+        confidence: Limiar de confiança
+
+    Returns:
+        Lista de detecções encontradas
+    """
+    pass
+```
+
+### 2. Estrutura de Arquivos
+```
+src/
+├── domain/
+│   ├── entities/
+│   │   └── detection.py
+│   └── interfaces/
+│       └── detector.py
+├── application/
+│   └── use_cases/
+│       └── process_video.py
+└── infrastructure/
+    └── services/
+        └── weapon_detector.py
+```
+
+### 3. Testes
+- pytest para testes unitários
+- pytest-cov para cobertura
+- Mocking para dependências externas
+
+Exemplo:
+```python
+def test_process_frame():
+    detector = WeaponDetector()
+    frame = np.zeros((640, 480, 3))
+    result = detector.process_frame(frame)
+    assert len(result) >= 0
+```
+
+## 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
+```
+
+### 3. Pull Requests
+- Template obrigatório
+- Code review necessário
+- CI deve passar
+- Squash merge preferido
+
+## CI/CD
+
+### GitHub Actions
+```yaml
+name: CI
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python
+        uses: actions/setup-python@v2
+      - name: Run tests
+        run: |
+          pip install -r requirements.txt
+          pytest
+```
+
+### Deploy
+1. Staging
+   ```bash
+   ./deploy.sh staging
+   ```
+
+2. Produção
+   ```bash
+   ./deploy.sh production
+   ```
+
+## Debugging
+
+### 1. Logs
+```python
+import logging
+
+logger = logging.getLogger(__name__)
+logger.info("Processando frame %d", frame_number)
+```
+
+### 2. Profiling
+```python
+import cProfile
+
+def profile_detection():
+    profiler = cProfile.Profile()
+    profiler.enable()
+    # código
+    profiler.disable()
+    profiler.print_stats()
+```
+
+### 3. GPU Monitoring
+```python
+import torch
+
+def check_gpu():
+    print(torch.cuda.memory_summary())
+```
+
+## Otimizações
+
+### 1. GPU
+- Batch processing
+- Memória pinned
+- Async data loading
+
+### 2. CPU
+- Multiprocessing
+- NumPy vectorization
+- Cache de resultados
+
+## Segurança
+
+### 1. Dependências
+- Safety check
+- Dependabot
+- SAST scanning
+
+### 2. Código
+- Input validation
+- Error handling
+- Secrets management
+
+## Documentação
+
+### 1. Docstrings
+```python
+def detect_objects(
+    self,
+    frame: np.ndarray
+) -> List[Detection]:
+    """Detecta objetos em um frame.
+
+    Args:
+        frame: Frame no formato BGR
+
+    Returns:
+        Lista de detecções
+
+    Raises:
+        ValueError: Se o frame for inválido
+    """
+    pass
+```
+
+### 2. Sphinx
+```bash
+cd docs
+make html
+```
+
+### 3. README
+- Badges atualizados
+- Exemplos práticos
+- Troubleshooting comum 

docs/setup/installation.md

@@ -0,0 +1,128 @@
+# Instalação e Configuração
+
+## Requisitos do Sistema
+
+### Hardware Recomendado
+- **GPU**: NVIDIA T4 16GB ou superior
+- **CPU**: 4+ cores
+- **RAM**: 16GB mínimo
+- **Armazenamento**: 10GB+ disponível
+
+### Software Necessário
+- Python 3.10+
+- CUDA 11.8+ (para GPU)
+- Git
+
+## Instalação Local
+
+1. Clone o repositório:
+```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
+```
+
+3. Instale as dependências:
+```bash
+pip install -r requirements.txt
+```
+
+4. Configure as variáveis de ambiente:
+```bash
+cp .env.example .env
+```
+
+Edite o arquivo `.env` com suas configurações:
+```
+HUGGINGFACE_TOKEN=seu_token
+GPU_MEMORY_FRACTION=0.9
+MAX_CONCURRENT_REQUESTS=2
+```
+
+## Configuração do Ambiente
+
+### GPU (NVIDIA)
+
+1. Verifique a instalação do CUDA:
+```bash
+nvidia-smi
+```
+
+2. Ajuste as configurações de GPU em `.env`:
+```
+USE_GPU=true
+GPU_DEVICE=0
+```
+
+### CPU
+
+Para usar apenas CPU:
+```
+USE_GPU=false
+```
+
+## Deployment no Hugging Face
+
+1. Configure as variáveis de ambiente do Hugging Face:
+```bash
+cp .env.example .env.huggingface
+```
+
+2. Edite `.env.huggingface`:
+```
+HF_SPACE_ID=seu-espaco
+HF_TOKEN=seu_token
+```
+
+3. Execute o deploy:
+```bash
+./deploy.sh
+```
+
+## Verificação da Instalação
+
+1. Execute os testes:
+```bash
+pytest
+```
+
+2. Inicie a aplicação:
+```bash
+python app.py
+```
+
+3. Acesse: http://localhost:7860
+
+## Troubleshooting
+
+### Problemas Comuns
+
+1. **Erro CUDA**
+   - Verifique a instalação do CUDA
+   - Confirme compatibilidade de versões
+
+2. **Memória Insuficiente**
+   - Ajuste `GPU_MEMORY_FRACTION`
+   - Reduza `MAX_CONCURRENT_REQUESTS`
+
+3. **Falha no Deploy**
+   - Verifique credenciais do Hugging Face
+   - Confirme permissões do espaço
+
+### Logs
+
+- Logs da aplicação: `logs/app.log`
+- Logs do GPU: `logs/gpu.log`
+
+## 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 

src/presentation/web/gradio_interface.py

@@ -239,16 +239,12 @@ class GradioInterface:
                                     format="mp4",
                                     height=150,
                                     interactive=True,
-                                    show_label=True).click(
-                                    fn=self.load_sample_video,
-                                    inputs=[gr.State(video['path'])],
-                                    outputs=[input_video]
-                                    )
+                                    show_label=True)
                                 
                             with gr.Column(scale=1, min_width=100):
                                 gr.Button(
                                     "📥 Carregar",
-                                    size="sm"
+                                    size="md"
                                 ).click(
                                     fn=self.load_sample_video,
                                     inputs=[gr.State(video['path'])],