Auto-deploy from GitHub

README.md

@@ -1,14 +1,131 @@
+# 🦟 PreviDengue
+
+### Uma Abordagem Multidisciplinar com Inteligência Artificial para o Monitoramento e Previsão da Dengue
+
+---
+
+[![Status](https://img.shields.io/badge/Status-Em%20Desenvolvimento-yellowgreen)](https://github.com/seu-usuario/seu-repo)
+[![Tecnologias](https://img.shields.io/badge/Python-3.x-blue)](https://www.python.org/)
+[![Licença](https://img.shields.io/badge/Licen%C3%A7a-MIT-blue)](https://github.com/seu-usuario/seu-repo/blob/main/LICENSE)
+
+---
+
+## 💡 Sobre o Projeto
+
+O **PreviDengue** é uma plataforma inovadora que integra inteligência artificial e dados geoespaciais e epidemiológicos para criar uma ferramenta poderosa no combate à dengue. O projeto, que nasceu da necessidade de soluções proativas de saúde pública, evoluiu para um sistema focado em dois pilares principais: a **detecção de focos do mosquito** e a **previsão de surtos epidemiológicos**.
+
+Nossa missão é fornecer aos agentes públicos e à comunidade uma ferramenta acessível e precisa, unificando a análise de dados complexos em um **dashboard intuitivo** que permite o planejamento estratégico de ações preventivas e de combate.
+
+---
+
+## 🌍 Veja o PreviDengue em Ação
+
+Você pode explorar a versão de demonstração do projeto e suas funcionalidades agora mesmo.
+
+**Acesse a plataforma aqui: [https://previdengue.vercel.app/](https://previdengue.vercel.app/)**
+
 ---
-title: PreviDengueAPI
-repository: https://github.com/IonMateus/PreviDengue
-subdirectory: api/
-emoji: 🦟
-colorFrom: blue
-colorTo: green
-sdk: docker
-pinned: false
-license: mit
-short_description: 'Identificação de Focos e Surtos de Dengue'
+
+## 🚀 Funcionalidades Principais
+
+---
+
+Nosso sistema é estruturado em dois módulos principais, ambos acessíveis através de uma interface unificada para uma análise composta dos dados.
+
+### **Módulo de Detecção de Focos 🛰️**
+
+Utilizamos Visão Computacional para analisar imagens aéreas de alta resolução e identificar potenciais criadouros do mosquito *Aedes aegypti*.
+
+> **🧠 Como Funciona:** O algoritmo **YOLO (You Only Look Once)** escaneia as imagens para detectar objetos como piscinas e caixas d'água. Cada área recebe uma **pontuação de risco** baseada nos criadouros identificados, e os resultados são exibidos em um **mapa de calor** interativo para fácil visualização.
+
+### **Módulo de Previsão de Surtos 📈**
+
+Este módulo utiliza modelos de aprendizado de máquina para prever a tendência de casos de dengue, auxiliando na alocação de recursos e na preparação de campanhas de saúde.
+
+> **🧠 Como Funciona:** Um modelo de **Rede Neural LSTM (Long Short-Term Memory)** é treinado com uma série histórica de dados do **DATASUS** e dados climáticos da **API da NASA**. A IA é capaz de capturar padrões complexos para prever picos de casos, permitindo que as autoridades tomem medidas preventivas antes que um surto se estabeleça.
+
+---
+
+## 🛠️ Tecnologias Utilizadas
+
+---
+
+Este projeto foi construído com uma stack de tecnologias modernas para garantir eficiência, escalabilidade e performance.
+
+| Categoria | Tecnologia |
+| :--- | :--- |
+| **Linguagem** | ![Python](https://img.shields.io/badge/Python-3.x-blue?style=for-the-badge&logo=python&logoColor=white) ![JavaScript](https://img.shields.io/badge/JavaScript-ES6+-F7DF1E?style=for-the-badge&logo=javascript&logoColor=black) |
+| **IA** | ![YOLO](https://img.shields.io/badge/YOLO-Ultralytics-orange?style=for-the-badge&logo=yolo&logoColor=white) ![LSTM](https://img.shields.io/badge/LSTM-Neural%20Network-red?style=for-the-badge&logo=tensorflow&logoColor=white) |
+| **Backend** | ![FastAPI](https://img.shields.io/badge/FastAPI-0.111.0-009688?style=for-the-badge&logo=fastapi) |
+| **Frontend** | ![Next.js](https://img.shields.io/badge/Next.js-14-black?style=for-the-badge&logo=next.js&logoColor=white) |
+| **Hospedagem** | ![Vercel](https://img.shields.io/badge/Vercel-000000?style=for-the-badge&logo=vercel&logoColor=white) ![Hugging Face](https://img.shields.io/badge/Hugging%20Face-FFBE00?style=for-the-badge&logo=hugging-face&logoColor=black) |
+
+---
+
+## 🏗️ Arquitetura do Sistema
+
+---
+
+O **PreviDengue** é composto por uma arquitetura em camadas que garante flexibilidade e desacoplamento entre os componentes.
+
+### **Frontend**
+A interface web, desenvolvida com **[Nome da Tecnologia]**, é a camada de apresentação que interage com o usuário. Ela se comunica com o backend para exibir o dashboard, o mapa de calor e permitir a submissão de imagens.
+
+### **Backend**
+Construído com **FastAPI**, o backend atua como um hub central. Ele recebe as requisições do frontend, gerencia o fluxo de dados e se comunica com as APIs dos modelos de IA para obter os resultados de detecção e previsão.
+
+### **Módulos de IA**
+Os modelos **YOLO** (para detecção) e **LSTM** (para previsão) são treinados em ambiente de nuvem (**Google Colab**) e expostos como **APIs RESTful** separadas, utilizando a plataforma **Hugging Face**. Essa abordagem garante que o processamento pesado seja feito na nuvem, otimizando o desempenho do sistema.
+
+---
+
+## 🧭 Como Usar
+
+---
+
+O projeto ainda está em desenvolvimento, mas o código-fonte estará disponível em breve. Para rodar a aplicação localmente:
+
+1.  Clone este repositório:
+    ```bash
+    git clone [https://github.com/seu-usuario/seu-repo.git](https://github.com/seu-usuario/seu-repo.git)
+    cd seu-repo
+    ```
+2.  Instale as dependências. Siga as instruções específicas nas pastas `backend` e `frontend`.
+    ```bash
+    # Para o backend
+    pip install -r requirements.txt
+    # Para o frontend
+    npm install
+    ```
+3.  Inicie o servidor de desenvolvimento.
+    ```bash
+    # Primeiro, inicie o backend
+    python main.py
+    # Em um novo terminal, inicie o frontend
+    npm run dev
+    ```
+
+> **Nota:** Certifique-se de configurar as variáveis de ambiente necessárias para acessar as APIs de IA.
+
+---
+
+## 🧑‍🤝‍🧑 Equipe
+
+---
+
+O **PreviDengue** é um projeto de Trabalho de Conclusão de Curso do Colégio Técnico de Campinas (COTUCA - UNICAMP), desenvolvido por:
+
+* **Arthur Gama Jorge** – [cc23578@g.unicamp.br](mailto:cc23578@g.unicamp.br)
+* **Daniel Dorigan de Carvalho Campos** – [cc23124@g.unicamp.br](mailto:cc23124@g.unicamp.br)
+* **Ion Mateus Nunes Oprea** – [cc23135@g.unicamp.br](mailto:cc23135@g.unicamp.br)
+
+**Orientadora:** Andréia
+**Coorientador:** Guilherme
+
+---
+
+## 📜 Licença
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Este projeto está licenciado sob a Licença **[Nome da Licença, ex: MIT]** - veja o arquivo [LICENSE.md](https://github.com/seu-usuario/seu-repo/blob/main/LICENSE) para mais detalhes.

api/.gitattributes

@@ -0,0 +1,38 @@
+pip install git-filter-repo
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+models/checkpoints/*.keras filter=lfs diff=lfs merge=lfs -text
+*.keras filter=lfs diff=lfs merge=lfs -text

api/app.py

@@ -0,0 +1,84 @@
+import uvicorn
+from fastapi import Body, FastAPI, UploadFile, File, Response 
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import traceback
+import numpy as np 
+import json 
+
+from detect import DengueDetector
+from predict import DenguePredictor  
+
+def default_json_serializer(obj):
+    if isinstance(obj, np.integer):
+        return int(obj)
+    elif isinstance(obj, np.floating):
+        return float(obj)
+    elif isinstance(obj, np.ndarray):
+        return obj.tolist()
+    raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable")
+
+detector: DengueDetector = None
+predictor: DenguePredictor = None
+
+app = FastAPI()
+
+# --- Crie um evento de startup para carregar os modelos ---
+@app.on_event("startup")
+async def startup_event():
+    global detector, predictor
+    print("Executando evento de startup: Carregando os módulos de IA...")
+    detector = DengueDetector()
+    predictor = DenguePredictor()
+    print("Módulos de IA carregados com sucesso. API pronta.")
+
+# --- CORS ---
+origins = ["https://previdengue.vercel.app", "http://localhost:3000", "*"]
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"]
+)
+
+# --- Rotas ---
+@app.get("/")
+def health_check():
+    return {"status": "ok", "message": "API de Dengue rodando!"}
+
+@app.post("/detect/")
+async def detect(file: UploadFile = File(...)):
+    if detector is None:
+        return JSONResponse(status_code=503, content={"error": "Detector ainda não foi inicializado."})
+    try:
+        content = await file.read()
+        result = detector.detect_image(content)  
+        return JSONResponse(content=result)
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": str(e)})
+
+
+@app.post("/predict/")
+async def predict_dengue_route(payload: dict = Body(...)):
+    if predictor is None:
+        return JSONResponse(status_code=503, content={"error": "Preditor ainda não foi inicializado."})
+    try:
+        ibge_code_str = payload.get("ibge_code")
+        if ibge_code_str is None:
+            raise ValueError("O campo 'ibge_code' é obrigatório.")
+        
+        ibge_code = int(ibge_code_str)
+        result = predictor.predict(ibge_code)
+        
+        json_content = json.dumps(result, default=default_json_serializer)
+        
+        return Response(content=json_content, media_type="application/json")
+
+    except Exception as e:
+        tb_str = traceback.format_exc()
+        print(tb_str) 
+        return JSONResponse(status_code=500, content={
+            "error": str(e),
+            "traceback": tb_str 
+        })

api/detect.py

@@ -0,0 +1,54 @@
+from collections import Counter
+import numpy as np
+from PIL import Image
+from io import BytesIO
+from ultralytics import YOLO
+
+class DengueDetector:
+    def __init__(self, model_path="./models/DetectsmallTest1.pt"):
+        self.model = YOLO(model_path)
+        self.names = self.model.names
+
+    def calculate_intensity(self, objects):
+        weights = {"piscina": 9, "caixa_agua": 4, "carro": 1}
+        score = sum(weights.get(obj["class"], 0) for obj in objects)
+        return score
+
+    def detect_image(self, image_bytes):
+        # Carregar imagem da memória
+        img = Image.open(BytesIO(image_bytes)).convert("RGB")
+        img_np = np.array(img)  # YOLO aceita np.array diretamente
+        height, width = img_np.shape[:2]
+
+        # Detectar objetos
+        results = self.model(img_np)
+        result = results[0]
+        boxes = result.boxes
+        class_ids = boxes.cls.tolist()
+        confidences = boxes.conf.tolist()
+        class_names = [self.names[int(cls)] for cls in class_ids]
+        counts = Counter(class_names)
+
+        # Construir lista de detecções
+        detections = []
+        for i in range(len(boxes)):
+            x1, y1, x2, y2 = map(float, boxes.xyxy[i])
+            conf = float(confidences[i])
+            cls_id = int(class_ids[i])
+            detections.append({
+                "class": self.names[cls_id],
+                "confidence": round(conf, 4),
+                "box": {
+                    "x1": x1, "y1": y1, "x2": x2, "y2": y2,
+                    "original_width": width, "original_height": height
+                }
+            })
+
+        intensity_score = self.calculate_intensity(detections)
+
+        return {
+            "total": len(class_ids),
+            "contagem": counts,
+            "objetos": detections,
+            "intensity_score": intensity_score
+        }

api/models/DetectsmallTest1.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b4b91b6b7d56edae2d369cb6b7306690a9864a1a51d2bf4f1bd6d2877ccf79c
+size 22508451

api/models/checkpoints/model_checkpoint_best_city.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b2f243729883b59055234a45b00f16892e60e5b948003ec3c27dc4d022e88a5
+size 2505166

api/models/checkpoints/test_checkpoint1.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3864073b783dad22b1833e95531c6d78df30556af7131d258aa91e7b0fdc5cc
+size 421650

api/models/scalers/scaler_dyn_global.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dce234dbd10d12bc0535d23089905f873dc98235550b601e70b702a8665d682f
+size 907

api/models/scalers/scaler_static_global.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9699ae64d444fc4453c6524ad3d4d44f7ca09e8bf4f3439c9f19a82f3745e266
+size 743

api/models/scalers/scaler_target_global.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:981c50a1405169907c95f8e20555949cca362d672f7ee48992e9c31760f85fd8
+size 799

api/predict.py

@@ -0,0 +1,203 @@
+import os
+import numpy as np
+import pandas as pd
+import joblib
+import warnings
+from pathlib import Path
+from datetime import timedelta
+import tensorflow as tf
+import matplotlib.pyplot as plt
+import base64
+from io import BytesIO
+from huggingface_hub import hf_hub_download 
+
+warnings.filterwarnings('ignore')
+plt.style.use('seaborn-v0_8-darkgrid')
+
+# --- MUDANÇA: Definição da loss customizada necessária para carregar o modelo ---
+def asymmetric_mse(y_true, y_pred):
+    penalty_factor = 5.0
+    error = y_true - y_pred
+    penalty = tf.where(error > 0, penalty_factor, 1.0)
+    loss = tf.square(error) * penalty
+    return tf.reduce_mean(loss)
+
+class DenguePredictor:
+    def __init__(self, project_root=None):
+        self.project_root = Path(project_root) if project_root else Path(__file__).resolve().parent
+        # --- MUDANÇA: Constantes do modelo alinhadas com o treinamento final ---
+        self.sequence_length = 12
+        self.horizon = 8
+        self.year_min_train = 2014
+        self.year_max_train = 2025
+        self.dynamic_features = [
+            "numero_casos", "casos_velocidade", "casos_aceleracao", "casos_mm_4_semanas",
+            "T2M", "T2M_MAX", "T2M_MIN", "PRECTOTCORR", "RH2M", "ALLSKY_SFC_SW_DWN",
+            "week_sin", "week_cos", "year_norm"
+        ]
+        self.static_features = ["latitude", "longitude"]
+        self.feature_names_pt = {
+            "numero_casos": "Nº de Casos de Dengue", "T2M": "Temperatura Média (°C)",
+            "PRECTOTCORR": "Precipitação (mm)"
+        }
+        self.load_assets()
+
+    def load_assets(self):
+        print("INFO: Carregando todos os ativos da IA (modelo, scalers, dados)...")
+        AI_ASSETS_DIR = self.project_root / "models"
+        
+        INFERENCE_PATH = hf_hub_download(
+            repo_id='previdengue/predict_inference_data', 
+            filename='inference_data.parquet', 
+            repo_type='dataset',
+            token=os.environ.get('HF_TOKEN') 
+        )
+        
+        SCALER_DIR = AI_ASSETS_DIR / "scalers"
+        MODEL_PATH = AI_ASSETS_DIR / "checkpoints" / "model_checkpoint_best_city.keras"
+
+        # --- MUDANÇA: Carregamento dos scalers GLOBAIS ---
+        self.scaler_dyn = joblib.load(SCALER_DIR / "scaler_dyn_global.pkl")
+        self.scaler_static = joblib.load(SCALER_DIR / "scaler_static_global.pkl")
+        self.scaler_target = joblib.load(SCALER_DIR / "scaler_target_global.pkl")
+
+        # Lê os dados de inferência do arquivo baixado
+        df_master = pd.read_parquet(INFERENCE_PATH)
+        df_master['codigo_ibge'] = df_master['codigo_ibge'].astype(int)
+        df_master['date'] = pd.to_datetime(df_master['ano'].astype(str) + df_master['semana'].astype(str) + '0', format='%Y%W%w', errors='coerce')
+        df_master = df_master.sort_values(by=['codigo_ibge', 'date']).reset_index(drop=True)
+        self.df_master = df_master
+        self.municipios = df_master[['codigo_ibge', 'municipio']].drop_duplicates().sort_values('codigo_ibge')
+
+        # --- MUDANÇA: Carregamento do modelo com a loss customizada ---
+        self.model = tf.keras.models.load_model(MODEL_PATH, custom_objects={'asymmetric_mse': asymmetric_mse})
+        print("INFO: Ativos da IA carregados com sucesso.")
+
+    def plot_to_base64(self, fig):
+        buf = BytesIO()
+        fig.savefig(buf, format='png', bbox_inches='tight', facecolor='#18181b')
+        buf.seek(0)
+        img_str = base64.b64encode(buf.read()).decode('utf-8')
+        plt.close(fig)
+        return img_str
+
+    def predict(self, ibge_code: int):
+        df_mun = self.df_master[self.df_master['codigo_ibge'] == ibge_code].copy()
+        if df_mun.empty or len(df_mun) < self.sequence_length:
+            raise ValueError(f"Não há dados ou histórico suficiente para o município {ibge_code}")
+
+        municipio_name = self.municipios[self.municipios['codigo_ibge'] == ibge_code].iloc[0]['municipio']
+
+        # 1. Pega a última sequência de dados históricos completos
+        last_complete_sequence = df_mun.dropna(subset=['numero_casos']).tail(self.sequence_length).copy()
+        if len(last_complete_sequence) < self.sequence_length:
+            raise ValueError(f"Histórico insuficiente de casos conhecidos para {ibge_code}")
+
+        # 2. Engenharia de Features na sequência de entrada
+        last_complete_sequence['casos_velocidade'] = last_complete_sequence['numero_casos'].diff().fillna(0)
+        last_complete_sequence['casos_aceleracao'] = last_complete_sequence['casos_velocidade'].diff().fillna(0)
+        last_complete_sequence['casos_mm_4_semanas'] = last_complete_sequence['numero_casos'].rolling(4, min_periods=1).mean()
+        last_complete_sequence['week_sin'] = np.sin(2 * np.pi * last_complete_sequence['semana'] / 52)
+        last_complete_sequence['week_cos'] = np.cos(2 * np.pi * last_complete_sequence['semana'] / 52)
+        last_complete_sequence['year_norm'] = (last_complete_sequence['ano'] - self.year_min_train) / (self.year_max_train - self.year_min_train)
+
+        # 3. Prepara os dados de entrada para o modelo
+        dynamic_input_raw = last_complete_sequence[self.dynamic_features].values
+        static_input_raw = last_complete_sequence[self.static_features].iloc[-1].values.reshape(1, -1)
+        
+        dynamic_input_scaled = self.scaler_dyn.transform(dynamic_input_raw).reshape(1, self.sequence_length, -1)
+        static_input_scaled = self.scaler_static.transform(static_input_raw)
+
+        # 4. Faz a predição (tiro único)
+        predictions_scaled = self.model.predict([dynamic_input_scaled, static_input_scaled], verbose=0)
+        pred_casos_scaled = predictions_scaled[0] # Primeira saída do modelo
+
+        # 5. Inverte a transformação para obter o número de casos reais
+        pred_casos_log = self.scaler_target.inverse_transform(pred_casos_scaled.reshape(1, -1))
+        pred_casos_real = np.expm1(pred_casos_log).flatten()
+        
+        predictions_final = [max(0, round(case)) for case in pred_casos_real]
+
+        # 6. Formata a resposta
+        last_real_date = last_complete_sequence['date'].iloc[-1]
+        predicted_data = [{
+            "date": (last_real_date + timedelta(weeks=i + 1)).strftime('%Y-%m-%d'),
+            "predicted_cases": cases
+        } for i, cases in enumerate(predictions_final)]
+
+        historic_data = [{
+            "date": row['date'].strftime('%Y-%m-%d'),
+            "cases": int(row["numero_casos"]) if pd.notna(row["numero_casos"]) else None
+        } for _, row in df_mun.tail(52).iterrows()]
+
+        # Geração de insights (Análise de Lag)
+        lag_plot_b64, strategic_summary, tipping_points = self.generate_lag_insights(df_mun)
+
+        return {
+            "municipality_name": municipio_name,
+            "historic_data": historic_data,
+            "predicted_data": predicted_data,
+            "insights": {
+                "lag_analysis_plot_base64": lag_plot_b64,
+                "strategic_summary": strategic_summary,
+                "tipping_points": tipping_points
+            }
+        }
+    
+    def generate_lag_insights(self, df_mun):
+        # Renomeia as colunas para a análise e para os gráficos
+        df_analysis = df_mun.rename(columns={"T2M": "Temperatura Média (°C)", "PRECTOTCORR": "Precipitação (mm)"})
+        max_lag = 12
+        cases_col_name = 'numero_casos'
+        lag_features = ['Temperatura Média (°C)', 'Precipitação (mm)']
+        lag_correlations = {}
+
+        # Calcula a correlação para cada feature com diferentes defasagens (lags)
+        for col in lag_features:
+            # Garante que a coluna existe antes de tentar usá-la
+            if col in df_analysis.columns:
+                corrs = [df_analysis[cases_col_name].corr(df_analysis[col].shift(lag)) for lag in range(1, max_lag + 1)]
+                lag_correlations[col] = corrs
+        
+        # Cria a figura para o gráfico
+        fig, ax = plt.subplots(figsize=(10, 6), facecolor='#18181b')
+        ax.set_facecolor('#18181b')
+        
+        # Plota as correlações
+        for feature_name, corrs in lag_correlations.items():
+            ax.plot(range(1, max_lag + 1), corrs, marker='o', linestyle='-', label=feature_name)
+        
+        # Estiliza o gráfico
+        ax.set_title('Análise de Defasagem (Lag)', color='white')
+        ax.set_xlabel('Defasagem (Semanas)', color='white')
+        ax.set_ylabel('Correlação com Casos', color='white')
+        ax.tick_params(colors='white')
+        ax.legend(facecolor='#27272a', edgecolor='gray', labelcolor='white')
+        ax.grid(True, which='both', linestyle='--', linewidth=0.5, color='#444')
+        
+        # Converte o gráfico para base64 para enviar na resposta da API
+        lag_plot_b64 = self.plot_to_base64(fig)
+
+        # Encontra o pico de correlação para cada feature
+        lag_peaks = {
+            feature: (np.argmax(np.abs(corrs)) + 1) if corrs and not all(pd.isna(corrs)) else 'N/A' 
+            for feature, corrs in lag_correlations.items()
+        }
+        temp_lag = lag_peaks.get('Temperatura Média (°C)', 'N/A')
+        rain_lag = lag_peaks.get('Precipitação (mm)', 'N/A')
+
+        # Cria um resumo estratégico
+        summary = (
+            f"A IA identifica a **Temperatura** e a **Precipitação** como os principais gatilhos climáticos. "
+            f"O impacto da temperatura tende a ser máximo após **{temp_lag} semanas**, enquanto o da chuva ocorre após **{rain_lag} semanas**. "
+            "Ações preventivas devem ser intensificadas nesta janela após eventos climáticos extremos."
+        )
+        
+        # Cria os pontos-chave (tipping points)
+        tipping_points = [
+            {"factor": "Temperatura", "value": f"Impacto máximo em {temp_lag} semanas"},
+            {"factor": "Precipitação", "value": f"Impacto máximo em {rain_lag} semanas"},
+            {"factor": "Umidade", "value": "Aumenta a sobrevida do mosquito adulto"},
+        ]
+        
+        return lag_plot_b64, summary, tipping_points

api/requirements.txt

@@ -0,0 +1,16 @@
+fastapi==0.115.12
+uvicorn==0.34.0
+pillow==11.1.0
+opencv-python-headless
+numpy==2.1.1
+ultralytics==8.3.105
+torch==2.6.0
+python-multipart
+joblib==1.5.1
+pandas==2.2.3
+matplotlib==3.10.3
+tensorflow==2.20.0
+epiweeks==2.3.0
+scikit-learn==1.6.1
+fastparquet
+huggingface_hub