Update main.py

main.py

@@ -4,18 +4,30 @@ from pydantic import BaseModel
 import pandas as pd
 import numpy as np
 import joblib
+import random
+from datetime import datetime
 
 # --- 1. CONFIGURAÇÃO ---
 app = FastAPI(title="EcoHull AI - Transpetro API", description="Previsão de Bioincrustação e Perda de Performance")
 
-# Carregar Modelos
+# Carregar Modelos (Certifique-se que os nomes dos arquivos estão iguais no HF)
 try:
-    model = joblib.load("modelo_casco.joblib")
-    regua_fisica = joblib.load("regua_fisica.joblib")
-    le = joblib.load("label_encoder.joblib")
+    # Ajuste os nomes aqui se você subiu com nomes diferentes (ex: modelo_casco_voting_v2.joblib)
+    # Vou usar os nomes genéricos que vi no seu código anterior, ajuste se necessário
+    model = joblib.load("modelo_casco_voting_v2.joblib") 
+    regua_fisica = joblib.load("regua_fisica_consumo.joblib")
+    le = joblib.load("label_encoder_lof.joblib")
     print("✅ Modelos carregados no servidor!")
 except Exception as e:
-    print(f"❌ Erro ao carregar modelos: {e}")
+    print(f"⚠️ Aviso: Tentando carregar com nomes alternativos... Erro original: {e}")
+    try:
+        # Fallback para os nomes antigos caso você não tenha renomeado
+        model = joblib.load("modelo_casco.joblib")
+        regua_fisica = joblib.load("regua_fisica.joblib")
+        le = joblib.load("label_encoder.joblib")
+        print("✅ Modelos (versão antiga) carregados!")
+    except:
+        print("❌ CRÍTICO: Não foi possível carregar os modelos.")
 
 # Segurança (Simples)
 API_KEY = "hackathon_transpetro_2025" 
@@ -25,22 +37,62 @@ async def get_api_key(api_key_header: str = Security(api_key_header)):
     if api_key_header == API_KEY: return api_key_header
     raise HTTPException(status_code=403, detail="Token Inválido")
 
-# --- 2. MODELO DE DADOS (O que o Backend deve mandar) ---
+# --- 2. MODELO DE DADOS (Input) ---
 class DadosNavio(BaseModel):
     shipName: str
-    speed: float       # Nós
-    duration: float    # Horas
-    distance: float    # Milhas
-    beaufortScale: int 
+    speed: float       
+    duration: float    
+    distance: float    
+    beaufortScale: int     
     Area_Molhada: float
     MASSA_TOTAL_TON: float
-    TIPO_COMBUSTIVEL_PRINCIPAL: str # "VLSFO", "MGO"
+    TIPO_COMBUSTIVEL_PRINCIPAL: str 
     decLatitude: float
     decLongitude: float
     DiasDesdeUltimaLimpeza: float
 
-# --- 3. PIPELINE DE ENGENHARIA (A Mágica) ---
-def processar_dados(data: dict):
+# --- 3. LÓGICA DE NEGÓCIO E FÍSICA ---
+
+def calcular_detalhes_biofouling(pred_lof, perda_performance, risco_regional):
+    """
+    Função V3.1: Calcula % precisa e Tipo de Incrustação
+    """
+    # A. Porcentagem
+    ranges = {0: (0.0, 0.0), 1: (1.0, 5.0), 2: (6.0, 15.0), 3: (16.0, 40.0), 4: (41.0, 85.0)}
+    teto_perda = {0:100, 1:600, 2:2500, 3:6000, 4:12000}
+    
+    min_p, max_p = ranges.get(pred_lof, (0, 0))
+    max_loss = teto_perda.get(pred_lof, 5000)
+    
+    pct_base = (min_p + max_p) / 2
+    if max_loss > 0 and perda_performance > 0:
+        fator = min(perda_performance / max_loss, 1.0)
+        pct_base = min_p + (fator * (max_p - min_p))
+    
+    # Jitter (usando perda como semente para consistência)
+    random.seed(int(abs(perda_performance)))
+    ajuste = random.uniform(-0.9, 0.9)
+    pct_final = round(pct_base + ajuste, 1)
+    
+    # Travas
+    pct_final = max(min_p, min(pct_final, max_p))
+    if pred_lof == 0: pct_final = 0.0
+    if pred_lof == 4: pct_final = max(40.1, pct_final)
+
+    # B. Tipo
+    tipo = "Indefinido"
+    if pred_lof == 0: tipo = "Limpo / Liso"
+    elif pred_lof == 1: tipo = "Biofilme (Limo Leve)"
+    elif pred_lof == 2: 
+        tipo = "Incrustação Mole Espessa" if risco_regional >= 4 else "Incrustação Mole (Slime)"
+    elif pred_lof == 3: 
+        tipo = "Mista (Limo + Cracas)" if perda_performance > 3000 else "Mole Severa (Algas)"
+    elif pred_lof >= 4: 
+        tipo = "Craca Dura / Calcária"
+        
+    return pct_final, tipo
+
+def processar_dataframe(data: dict):
     df = pd.DataFrame([data])
     
     # A. Geo Risk
@@ -67,55 +119,61 @@ def processar_dados(data: dict):
     df['fator_energia'] = df['TIPO_COMBUSTIVEL_PRINCIPAL'].apply(get_densidade)
     df['ENERGIA_CALCULADA_MJ'] = df['MASSA_TOTAL_TON'] * 1000 * df['fator_energia']
 
-    # C. Física (Usando a Régua Carregada)
+    # C. Física (Regressão Linear Externa)
     df['velocidade_cubo'] = df['speed'] ** 3
     X_regua = (df['velocidade_cubo'] * df['duration']).values.reshape(-1,1)
     
-    # Previsão da régua
     df['ENERGIA_ESPERADA'] = regua_fisica.predict(X_regua)
     df['PERFORMANCE_LOSS_MJ'] = df['ENERGIA_CALCULADA_MJ'] - df['ENERGIA_ESPERADA']
 
-    # Seleção Final
+    # Seleção Final (Ordem Importa!)
     cols = ['speed', 'duration', 'distance', 'beaufortScale', 
             'Area_Molhada', 'PERFORMANCE_LOSS_MJ', 
             'DiasDesdeUltimaLimpeza', 'velocidade_cubo', 'RISCO_REGIONAL']
     
     return df[cols].fillna(0)
 
-# --- 4. ENDPOINT (Onde o Backend bate) ---
+# --- 4. ENDPOINT ---
 @app.post("/predict")
 def predict(dados: DadosNavio, token: str = Security(get_api_key)):
     try:
-        # 1. Processar
-        df_pronto = processar_dados(dados.dict())
+        # 1. Processar dados brutos -> features
+        df_pronto = processar_dataframe(dados.dict())
         
-        # 2. Predizer
+        # 2. Predizer Classe (LOF)
         pred_encoded = model.predict(df_pronto)[0]
-        pred_label = int(pred_encoded)
-        
-        # 3. Decodificar (Label Encoder opcional se soubermos que 0-4 é LOF)
-        # Vamos retornar o número e o texto
-        texto_lof = ["BOM", "REGULAR", "ATENÇÃO", "RUIM", "CRÍTICO"][pred_label]
+        try:
+            pred_lof = int(le.inverse_transform([int(pred_encoded)])[0])
+        except:
+            pred_lof = int(pred_encoded) # Fallback se não tiver encoder
         
-        # 4. Cálculo Financeiro Rápido (Estimativa)
+        # 3. Calcular Detalhes (A Inteligência Nova)
         perda_mj = float(df_pronto['PERFORMANCE_LOSS_MJ'].values[0])
+        risco_reg = float(df_pronto['RISCO_REGIONAL'].values[0])
+        
+        pct_cobertura, tipo_incrustacao = calcular_detalhes_biofouling(pred_lof, perda_mj, risco_reg)
+
+        # 4. Cálculo Financeiro Rápido
         prejuizo_usd = (perda_mj / 41200.0) * 650.0 if perda_mj > 0 else 0.0
 
         return {
             "status": "sucesso",
             "navio": dados.shipName,
-            "lof_previsto": pred_label,
-            "condicao_texto": texto_lof,
-            "dados_tecnicos": {
+            "resultado_lof": pred_lof,
+            "detalhes_tecnicos": {
+                "porcentagem_cobertura": f"{pct_cobertura}%",
+                "tipo_incrustacao": tipo_incrustacao,
                 "perda_performance_mj": round(perda_mj, 2),
-                "risco_regional": float(df_pronto['RISCO_REGIONAL'].values[0]),
-                "prejuizo_estimado_viagem_usd": round(prejuizo_usd, 2)
+                "risco_regional": risco_reg,
+                "prejuizo_estimado_usd": round(prejuizo_usd, 2)
             },
-            "recomendacao": "AGENDAR LIMPEZA" if pred_label >= 3 else "MONITORAR"
+            "mensagem_laudo": f"LOF {pred_lof} ({pct_cobertura}% - {tipo_incrustacao})",
+            "recomendacao": "AGENDAR LIMPEZA IMEDIATA" if pred_lof >= 3 else "MANTER MONITORAMENTO"
         }
+
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 @app.get("/")
 def home():
-    return {"msg": "API EcoHull Online. Use POST /predict"}
+    return {"msg": "API EcoHull Online V3.1 - Com Detecção de Tipo e Porcentagem"}