update fleven-server

.gitignore

@@ -0,0 +1,22 @@
+# Python
+__pycache__/
+*.pyc
+venv/
+
+# Flower
+.flwr/
+*.fab
+
+# Resultados
+results/
+metrics/
+mlartifacts/
+mlruns/
+data/
+
+*.pt
+*.pth
+
+# Jupyter Notebooks
+*.ipynb_checkpoints
+DataClientCreate.ipynb

Dockerfile

@@ -0,0 +1,26 @@
+# Usar uma imagem base Python slim
+FROM python:3.11-slim
+
+# Definir o diretório de trabalho dentro do contêiner
+WORKDIR /app
+
+# Copiar TODO o conteúdo do seu projeto para o diretório /app no contêiner
+# Incluindo a pasta 'fleven', 'pyproject.toml', etc.
+COPY . .
+
+# Instalar as dependências do projeto definidas no pyproject.toml
+# O "." indica para instalar o projeto no diretório atual
+RUN pip install --no-cache-dir .
+
+# Expor a porta que o servidor Flower (SuperNode) usará
+# O padrão do HF Spaces é 7860, mas vamos usar 8080 que é o padrão do Flower
+# O HF redirecionará o tráfego externo para esta porta interna
+EXPOSE 8080
+
+# Comando para iniciar o SERVIDOR Flower (SuperLink/SuperNode no modo servidor)
+# NÃO use 'flwr run .', que é para simulação. Use 'flower-supernode'.
+# '--app' aponta para seu objeto ServerApp em fleven/server.py
+# '--address 0.0.0.0:8080' faz o servidor ouvir em todas as interfaces na porta 8080 dentro do contêiner
+CMD ["flower-supernode", \
+     "--app", "fleven.server:app", \
+     "--address", "0.0.0.0:8080"]

fleven/analysis.py

@@ -0,0 +1,354 @@
+"""Funções para análise e visualização de resultados."""
+import matplotlib
+matplotlib.use("Agg")
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from pathlib import Path
+import json
+from datetime import datetime
+from fleven.collector import MetricsCollector
+
+plt.style.use('seaborn-v0_8-darkgrid')
+sns.set_palette("husl")
+
+
+def create_visualizations(collector: MetricsCollector, output_dir: Path):
+    """Cria todas as visualizações de desempenho."""
+
+    client_ids = collector.active_client_ids
+    print(f"Analisando clientes com IDs: {client_ids}")
+
+    # Para cores dinâmicas
+    colors = sns.color_palette("husl", n_colors=len(client_ids))
+    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
+    
+    # Subplot 1: Desempenho Global
+    ax1 = axes[0, 0]
+    rounds = collector.train_metrics["rounds"]
+    if len(rounds) > 0 and len(collector.train_metrics["global_train_loss"]) > 0:
+        ax1.plot(rounds, collector.train_metrics["global_train_loss"], 
+                 'b-', marker='s', label='Treino Global', linewidth=2)
+    if len(collector.eval_metrics["rounds"]) > 0 and len(collector.eval_metrics["global_eval_loss"]) > 0:
+        ax1.plot(collector.eval_metrics["rounds"], collector.eval_metrics["global_eval_loss"], 
+                 'r-', marker='o', label='Validação Global', linewidth=2)
+    ax1.set_title('Desempenho do Modelo Global', fontsize=14, fontweight='bold')
+    ax1.set_xlabel('Rodada')
+    ax1.set_ylabel('Perda (MSE)')
+    ax1.legend()
+    ax1.grid(True, alpha=0.3)
+    
+    # Subplot 2: Comparação entre Clientes (Treino)
+    ax2 = axes[0, 1]
+    colors = ['#2E7D32', '#1565C0', '#E65100']
+    
+    for idx, client_id in enumerate(client_ids):
+        key = f"client_{client_id}_train_loss"
+        if key in collector.train_metrics and collector.train_metrics[key]:
+            client_losses = collector.train_metrics[key]
+            if len(client_losses) > 0:
+                client_rounds = [r for r_idx, r in enumerate(rounds) if r_idx < len(client_losses)]
+                if len(client_rounds) == len(client_losses):
+                    ax2.plot(client_rounds, client_losses, 
+                             marker='o', label=f'Cliente {client_id}', color=colors[idx], linewidth=1.5)
+    
+    if len(rounds) > 0 and len(collector.train_metrics["global_train_loss"]) > 0:
+        ax2.plot(rounds, collector.train_metrics["global_train_loss"], 
+                 'k--', label='Média Global', linewidth=2, alpha=0.7)
+    ax2.set_title('Perda de Treinamento por Cliente', fontsize=14, fontweight='bold')
+    ax2.set_xlabel('Rodada')
+    ax2.set_ylabel('Perda de Treino (MSE)')
+    ax2.legend()
+    ax2.grid(True, alpha=0.3)
+    
+    # Subplot 3: Comparação entre Clientes (Validação)
+    ax3 = axes[1, 0]
+    eval_rounds = collector.eval_metrics["rounds"]
+
+    for idx, client_id in enumerate(client_ids):
+        key = f"client_{client_id}_eval_loss"
+        if key in collector.eval_metrics and collector.eval_metrics[key]:
+            client_losses = collector.eval_metrics[key]
+            if len(client_losses) > 0:
+                client_rounds = [r for r_idx, r in enumerate(eval_rounds) if r_idx < len(client_losses)]
+                if len(client_rounds) == len(client_losses):
+                    ax3.plot(client_rounds, client_losses, 
+                             marker='s', label=f'Cliente {client_id}', color=colors[idx], linewidth=1.5)
+    
+    if len(eval_rounds) > 0 and len(collector.eval_metrics["global_eval_loss"]) > 0:
+        ax3.plot(eval_rounds, collector.eval_metrics["global_eval_loss"], 
+                 'k--', label='Média Global', linewidth=2, alpha=0.7)
+    ax3.set_title('Perda de Validação por Cliente', fontsize=14, fontweight='bold')
+    ax3.set_xlabel('Rodada')
+    ax3.set_ylabel('Perda de Validação (MSE)')
+    ax3.legend()
+    ax3.grid(True, alpha=0.3)
+    
+    # Subplot 4: Taxa de Melhoria
+    ax4 = axes[1, 1]
+    if len(rounds) > 1 and len(collector.train_metrics["global_train_loss"]) > 1:
+        train_improvement = np.diff(collector.train_metrics["global_train_loss"])
+        ax4.plot(rounds[1:], train_improvement, 'g-', marker='v', label='Δ Treino', linewidth=1.5)
+    
+    if len(eval_rounds) > 1 and len(collector.eval_metrics["global_eval_loss"]) > 1:
+        eval_improvement = np.diff(collector.eval_metrics["global_eval_loss"])
+        ax4.plot(eval_rounds[1:], eval_improvement, 
+                'm-', marker='^', label='Δ Validação', linewidth=1.5)
+    
+    ax4.axhline(y=0, color='k', linestyle='--', alpha=0.5)
+    ax4.set_title('Taxa de Melhoria (Δ Perda)', fontsize=14, fontweight='bold')
+    ax4.set_xlabel('Rodada')
+    ax4.set_ylabel('Mudança na Perda')
+    ax4.legend()
+    ax4.grid(True, alpha=0.3)
+    
+    plt.suptitle(f'Análise de Desempenho - Estratégia: {collector.strategy_name.upper()}', 
+                 fontsize=16, fontweight='bold')
+    plt.tight_layout()
+    plt.savefig(output_dir / f'performance_analysis_{collector.strategy_name}.pdf', dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    # Gráfico de Convergência
+    _create_convergence_plot(collector, output_dir, eval_rounds)
+    
+    # Heatmap
+    _create_heatmap(collector, output_dir, eval_rounds)
+    
+    print(f"Visualizações salvas em {output_dir}")
+
+
+def _create_convergence_plot(collector: MetricsCollector, output_dir: Path, eval_rounds):
+    """Cria gráfico de convergência."""
+    client_ids = collector.active_client_ids
+    fig, axes = plt.subplots(1, 3, figsize=(18, 6))
+    
+    for round_idx, round_num in enumerate(eval_rounds):
+        client_losses = []
+        for client_id in client_ids:
+            key = f"client_{client_id}_eval_loss"
+            if key in collector.eval_metrics and round_idx < len(collector.eval_metrics[key]):
+                client_losses.append(collector.eval_metrics[key][round_idx])
+        
+        if len(client_losses) > 1:
+            var, std, diff = collector.calculate_convergence_metrics(client_losses)
+            collector.convergence_metrics["rounds"].append(round_num)
+            collector.convergence_metrics["loss_variance"].append(var)
+            collector.convergence_metrics["loss_std"].append(std)
+            collector.convergence_metrics["max_min_diff"].append(diff)
+    
+    if len(collector.convergence_metrics["rounds"]) > 0:
+        ax1 = axes[0]
+        ax1.plot(collector.convergence_metrics["rounds"], 
+                 collector.convergence_metrics["loss_variance"], 
+                 'b-', marker='o', linewidth=2)
+        ax1.fill_between(collector.convergence_metrics["rounds"], 
+                         collector.convergence_metrics["loss_variance"], 
+                         alpha=0.3)
+        ax1.set_title('Variância da Perda entre Clientes', fontsize=14, fontweight='bold')
+        ax1.set_xlabel('Rodada')
+        ax1.set_ylabel('Variância')
+        ax1.grid(True, alpha=0.3)
+        
+        ax2 = axes[1]
+        ax2.plot(collector.convergence_metrics["rounds"], 
+                 collector.convergence_metrics["loss_std"], 
+                 'g-', marker='s', linewidth=2)
+        ax2.fill_between(collector.convergence_metrics["rounds"], 
+                         collector.convergence_metrics["loss_std"], 
+                         alpha=0.3, color='green')
+        ax2.set_title('Desvio Padrão da Perda entre Clientes', fontsize=14, fontweight='bold')
+        ax2.set_xlabel('Rodada')
+        ax2.set_ylabel('Desvio Padrão')
+        ax2.grid(True, alpha=0.3)
+        
+        ax3 = axes[2]
+        ax3.plot(collector.convergence_metrics["rounds"], 
+                 collector.convergence_metrics["max_min_diff"], 
+                 'r-', marker='^', linewidth=2)
+        ax3.fill_between(collector.convergence_metrics["rounds"], 
+                         collector.convergence_metrics["max_min_diff"], 
+                         alpha=0.3, color='red')
+        ax3.set_title('Diferença Máx-Mín entre Clientes', fontsize=14, fontweight='bold')
+        ax3.set_xlabel('Rodada')
+        ax3.set_ylabel('Diferença')
+        ax3.grid(True, alpha=0.3)
+    else:
+        for ax in axes:
+            ax.text(0.5, 0.5, 'Dados insuficientes', 
+                   ha='center', va='center', transform=ax.transAxes)
+    
+    plt.suptitle(f'Análise de Convergência e Heterogeneidade - {collector.strategy_name.upper()}', 
+                 fontsize=16, fontweight='bold')
+    plt.tight_layout()
+    plt.savefig(output_dir / f'convergence_analysis_{collector.strategy_name}.pdf', dpi=300, bbox_inches='tight')
+    plt.close()
+
+
+def _create_heatmap(collector: MetricsCollector, output_dir: Path, eval_rounds):
+    """Cria heatmap de performance."""
+    client_ids = collector.active_client_ids
+    fig, ax = plt.subplots(figsize=(12, 6))
+    
+    heatmap_data = []
+    max_rounds = len(eval_rounds) if eval_rounds else 0
+    
+    has_data = False
+    for client_id in client_ids:
+        key = f"client_{client_id}_eval_loss"
+        if key in collector.eval_metrics and collector.eval_metrics[key]:
+            has_data = True
+            break
+    
+    if has_data and max_rounds > 0:
+        for client_id in client_ids:
+            key = f"client_{client_id}_eval_loss"
+            if key in collector.eval_metrics and collector.eval_metrics[key]:
+                client_data = list(collector.eval_metrics[key])
+                while len(client_data) < max_rounds:
+                    client_data.append(np.nan)
+                heatmap_data.append(client_data[:max_rounds])
+            else:
+                heatmap_data.append([np.nan] * max_rounds)
+        
+        heatmap_array = np.array(heatmap_data, dtype=float)
+        masked_array = np.ma.masked_invalid(heatmap_array)
+        
+        im = ax.imshow(masked_array, aspect='auto', cmap='RdYlGn_r')
+        
+        ax.set_xticks(range(max_rounds))
+        ax.set_xticklabels(eval_rounds[:max_rounds])
+        ax.set_yticks(range(len(client_ids)))
+        ax.set_yticklabels([f'Cliente {cid}' for cid in client_ids])
+        
+        ax.set_xlabel('Rodada', fontsize=12)
+        ax.set_title(f'Mapa de Calor - Perda de Validação por Cliente - {collector.strategy_name.upper()}', 
+                    fontsize=14, fontweight='bold')
+        
+        for i in range(len(heatmap_data)):
+            for j in range(min(len(heatmap_data[i]), max_rounds)):
+                if not np.isnan(heatmap_data[i][j]):
+                    text = ax.text(j, i, f'{heatmap_data[i][j]:.4f}',
+                                 ha="center", va="center", color="black", fontsize=8)
+        
+        plt.colorbar(im, ax=ax, label='Perda (MSE)')
+    else:
+        ax.text(0.5, 0.5, 'Dados insuficientes para gerar heatmap', 
+                ha='center', va='center', transform=ax.transAxes, fontsize=12)
+        ax.set_title(f'Mapa de Calor - Perda de Validação por Cliente - {collector.strategy_name.upper()}', 
+                    fontsize=14, fontweight='bold')
+    
+    plt.tight_layout()
+    plt.savefig(output_dir / f'heatmap_performance_{collector.strategy_name}.pdf', dpi=300, bbox_inches='tight')
+    plt.close()
+
+
+def save_detailed_metrics(collector: MetricsCollector, output_dir: Path):
+    """Salva métricas detalhadas em diferentes formatos."""
+    
+    # Salvar CSVs de treino e avaliação
+    if collector.train_metrics_by_round:
+        train_df = pd.DataFrame(collector.train_metrics_by_round)
+        train_df['phase'] = 'train'
+        train_csv = output_dir / f'train_metrics_{collector.strategy_name}.csv'
+        train_df.to_csv(train_csv, index=False)
+        print(f"Métricas de treino salvas em {train_csv}")
+    
+    if collector.eval_metrics_by_round:
+        eval_df = pd.DataFrame(collector.eval_metrics_by_round)
+        eval_df['phase'] = 'eval'
+        eval_csv = output_dir / f'eval_metrics_{collector.strategy_name}.csv'
+        eval_df.to_csv(eval_csv, index=False)
+        print(f"Métricas de avaliação salvas em {eval_csv}")
+
+    # Calcular estatísticas
+    stats = {
+        "strategy": collector.strategy_name,
+        "total_rounds": len(collector.train_metrics["rounds"]),
+        "final_global_train_loss": float(collector.train_metrics["global_train_loss"][-1]) if collector.train_metrics["global_train_loss"] else None,
+        "final_global_eval_loss": float(collector.eval_metrics["global_eval_loss"][-1]) if collector.eval_metrics["global_eval_loss"] else None,
+        "train_improvement": float((collector.train_metrics["global_train_loss"][0] - collector.train_metrics["global_train_loss"][-1])) if len(collector.train_metrics["global_train_loss"]) > 1 else 0,
+        "eval_improvement": float((collector.eval_metrics["global_eval_loss"][0] - collector.eval_metrics["global_eval_loss"][-1])) if len(collector.eval_metrics["global_eval_loss"]) > 1 else 0,
+        "timestamp": datetime.now().isoformat()
+    }
+    
+    if collector.convergence_metrics["rounds"]:
+        stats["convergence_metrics"] = {
+            "rounds": collector.convergence_metrics["rounds"],
+            "final_variance": float(collector.convergence_metrics["loss_variance"][-1]) if collector.convergence_metrics["loss_variance"] else None,
+            "final_std": float(collector.convergence_metrics["loss_std"][-1]) if collector.convergence_metrics["loss_std"] else None,
+            "final_max_min_diff": float(collector.convergence_metrics["max_min_diff"][-1]) if collector.convergence_metrics["max_min_diff"] else None,
+        }
+    
+    # Salvar JSON
+    json_file = output_dir / f'analysis_{collector.strategy_name}.json'
+    with open(json_file, 'w') as f:
+        json.dump(stats, f, indent=2)
+    print(f"Análise estatística salva em {json_file}")
+    
+    # Salvar sumário em texto
+    _save_summary_text(collector, stats, output_dir)
+
+
+def _save_summary_text(collector: MetricsCollector, stats: dict, output_dir: Path):
+    """Salva sumário em formato texto."""
+    summary_file = output_dir / f'summary_{collector.strategy_name}.txt'
+    with open(summary_file, 'w', encoding='utf-8') as f:
+        f.write("="*60 + "\n")
+        f.write(f"RELATÓRIO DE TREINAMENTO - {collector.strategy_name.upper()}\n")
+        f.write("="*60 + "\n\n")
+        
+        f.write(f"Data: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+        f.write(f"Total de rodadas: {stats['total_rounds']}\n\n")
+        
+        if stats['final_global_train_loss']:
+            f.write("--- MÉTRICAS DE TREINO ---\n")
+            f.write(f"Loss inicial: {collector.train_metrics['global_train_loss'][0]:.6f}\n")
+            f.write(f"Loss final: {stats['final_global_train_loss']:.6f}\n")
+            f.write(f"Melhoria: {stats['train_improvement']:.6f} ({(stats['train_improvement']/collector.train_metrics['global_train_loss'][0]*100):.2f}%)\n\n")
+        
+        if stats['final_global_eval_loss']:
+            f.write("--- MÉTRICAS DE AVALIAÇÃO ---\n")
+            f.write(f"Loss inicial: {collector.eval_metrics['global_eval_loss'][0]:.6f}\n")
+            f.write(f"Loss final: {stats['final_global_eval_loss']:.6f}\n")
+            f.write(f"Melhoria: {stats['eval_improvement']:.6f} ({(stats['eval_improvement']/collector.eval_metrics['global_eval_loss'][0]*100):.2f}%)\n\n")
+        
+        if 'convergence_metrics' in stats:
+            f.write("--- MÉTRICAS DE CONVERGÊNCIA ---\n")
+            f.write(f"Desvio padrão final: {stats['convergence_metrics']['final_std']:.6f}\n")
+            f.write(f"Variância final: {stats['convergence_metrics']['final_variance']:.6f}\n")
+            f.write(f"Diferença máx-mín final: {stats['convergence_metrics']['final_max_min_diff']:.6f}\n")
+    
+    print(f"Sumário salvo em {summary_file}")
+
+
+def print_final_summary(collector: MetricsCollector):
+    """Imprime sumário final no console."""
+    print("\n" + "="*60)
+    print("RESUMO DO TREINAMENTO")
+    print("="*60)
+    
+    if collector.train_metrics["global_train_loss"]:
+        initial_loss = collector.train_metrics["global_train_loss"][0]
+        final_loss = collector.train_metrics["global_train_loss"][-1]
+        improvement = ((initial_loss - final_loss) / initial_loss) * 100
+        
+        print(f"Perda inicial de treino: {initial_loss:.6f}")
+        print(f"Perda final de treino: {final_loss:.6f}")
+        print(f"Melhoria no treino: {improvement:.2f}%")
+    
+    if collector.eval_metrics["global_eval_loss"]:
+        initial_eval = collector.eval_metrics["global_eval_loss"][0]
+        final_eval = collector.eval_metrics["global_eval_loss"][-1]
+        eval_improvement = ((initial_eval - final_eval) / initial_eval) * 100
+        
+        print(f"\nPerda inicial de validação: {initial_eval:.6f}")
+        print(f"Perda final de validação: {final_eval:.6f}")
+        print(f"Melhoria na validação: {eval_improvement:.2f}%")
+    
+    # Análise de convergência
+    if collector.convergence_metrics["loss_std"]:
+        final_std = collector.convergence_metrics["loss_std"][-1]
+        print(f"\nDesvio padrão final entre clientes: {final_std:.6f}")
+        print(f"Convergência: {'Boa' if final_std < 0.01 else 'Moderada' if final_std < 0.05 else 'Baixa'}")

fleven/client.py

@@ -0,0 +1,285 @@
+import torch
+from flwr.app import Context, Message, ArrayRecord, MetricRecord, RecordDict
+from flwr.clientapp import ClientApp
+from fleven.utils import get_model, load_data, train, test, set_seed
+from pathlib import Path
+import json
+from datetime import datetime
+
+# Verifica se a GPU está disponível
+DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+class MetricsTracker:
+    """Classe para rastrear e salvar métricas locais do cliente."""
+    
+    def __init__(self, client_id, metrics_base_path=None):
+        self.client_id = client_id
+        
+        # 🔧 Define o diretório de métricas de forma robusta
+        if metrics_base_path:
+            # Usa o caminho configurado
+            self.metrics_dir = Path(metrics_base_path) / f"client_{self.client_id}"
+        else:
+            # Tenta usar caminho relativo ao arquivo atual
+            base_dir = Path(__file__).parent.parent
+            self.metrics_dir = base_dir / "metrics" / f"client_{self.client_id}"
+        
+        # Cria o diretório se não existir
+        self.metrics_dir.mkdir(parents=True, exist_ok=True)
+        self.history_file = self.metrics_dir / "metrics_history.json"
+        self.history = self.load_history()
+        
+        print(f"[Cliente {self.client_id}] Métricas serão salvas em: {self.metrics_dir.absolute()}")
+
+    def load_history(self):
+        if self.history_file.exists():
+            with open(self.history_file, 'r') as f:
+                return json.load(f)
+        return {"train": [], "eval": []}
+    
+    def get_next_round_number(self):
+        """Retorna o próximo número de rodada baseado no histórico."""
+        if not self.history["train"]:
+            return 1
+        return self.history["train"][-1]["round"] + 1
+
+    def add_train_metrics(self, round_num, loss):
+        existing_rounds = [entry["round"] for entry in self.history["train"]]
+        if round_num not in existing_rounds:
+            self.history["train"].append({
+                "round": round_num, 
+                "loss": loss, 
+                "timestamp": datetime.now().isoformat()
+            })
+        else:
+            for entry in self.history["train"]:
+                if entry["round"] == round_num:
+                    entry["loss"] = loss
+                    entry["timestamp"] = datetime.now().isoformat()
+                    break
+
+    def add_eval_metrics(self, round_num, loss):
+        existing_rounds = [entry["round"] for entry in self.history["eval"]]
+        if round_num not in existing_rounds:
+            self.history["eval"].append({
+                "round": round_num, 
+                "loss": loss, 
+                "timestamp": datetime.now().isoformat()
+            })
+        else:
+            for entry in self.history["eval"]:
+                if entry["round"] == round_num:
+                    entry["loss"] = loss
+                    entry["timestamp"] = datetime.now().isoformat()
+                    break
+
+    def save_metrics(self):
+        try:
+            with open(self.history_file, 'w') as f:
+                json.dump(self.history, f, indent=4)
+            print(f"[Cliente {self.client_id}] Métricas salvas com sucesso")
+        except Exception as e:
+            print(f"[Cliente {self.client_id}] AVISO: Não foi possível salvar métricas: {e}")
+
+    def save_checkpoint(self, net, round_num):
+        try:
+            model_path = self.metrics_dir / f"model_round_{round_num}.pt"
+            torch.save(net.state_dict(), model_path)
+            print(f"[Cliente {self.client_id}] Checkpoint salvo: {model_path}")
+        except Exception as e:
+            print(f"[Cliente {self.client_id}] AVISO: Não foi possível salvar checkpoint: {e}")
+
+# Estado do ator para evitar recarregar dados a cada rodada
+model_state = {
+    "net": None,
+    "trainloader": None,
+    "testloader": None,
+    "metrics_tracker": None,
+    "client_id": None,
+}
+
+def initialize_client_state(client_id: int, context: Context):
+    """Inicializa o estado do cliente lendo configurações do Context."""
+    if model_state["client_id"] == client_id:
+        return
+
+    global_seed = int(context.run_config.get("seed", 42))
+    # seed única para cada cliente
+    client_seed = global_seed + client_id
+    set_seed(client_seed)
+    print(f"[Cliente {client_id}] Usando seed local para replicação: {client_seed}")
+
+    print(f"Ator [Node {context.node_id}] a inicializar para Client ID: {client_id}")
+    
+    # lendo algumas configs do context
+    sequence_length = int(context.run_config.get("sequence-length", 60))
+    prediction_length = int(context.run_config.get("prediction-length", 10))
+    batch_size = int(context.run_config.get("batch-size", 32))
+    train_test_split = float(context.run_config.get("train-test-split", 0.8))
+
+    target_column = str(context.run_config.get("target-column", "P_kW"))
+    print(f"[Cliente {client_id}] Configurado para prever a coluna: '{target_column}'")
+
+    model_type = context.run_config.get("model-type", "lstm")
+    num_layers = int(context.run_config.get("num-layers", 1))
+
+    # Parâmetros para "lstm" e "mlp"
+    hidden_size = int(context.run_config.get("hidden-size", 32))
+    
+    # Parâmetros para "lstm_dense" (o novo modelo adaptado)
+    lstm_hidden_size = int(context.run_config.get("lstm-hidden-size", 32))
+    dense_hidden_size = int(context.run_config.get("dense-hidden-size", 16))
+    
+    # Parâmetro de Dropout para "lstm" e "lstm_dense"
+    dropout = float(context.run_config.get("dropout", 0.0))
+        
+    # 🔧 Lê os caminhos configurados
+    data_base_path = context.run_config.get("data-base-path", None)
+    metrics_base_path = context.run_config.get("metrics-base-path", None)
+    
+    # Carrega dados com as configurações
+    trainloader, testloader, num_features = load_data(
+        client_id, 
+        sequence_length, 
+        prediction_length,
+        batch_size,
+        train_test_split,
+        data_base_path=data_base_path,
+        target_column=target_column
+    )
+
+    # -todos os parâmetros para o model_config::
+    
+    # 🔧 Dicionário de configuração do modelo
+    model_config = {
+        "name": model_type,
+        "input_size": num_features, # retornado pelo load_data
+        "output_size": prediction_length,
+        "num_layers": num_layers,
+        "sequence_length": sequence_length,
+        
+        # Parâmetros para "lstm" e "mlp"
+        "hidden_size": hidden_size,
+        
+        # Parâmetros para "lstm_dense"
+        "lstm_hidden_size": lstm_hidden_size,
+        "dense_hidden_size": dense_hidden_size,
+        
+        # Parâmetro de Dropout
+        "dropout": dropout
+    }
+        
+    # Cria rede com as configurações
+    net = get_model(model_config).to(DEVICE)
+    
+    model_state.update({
+        "net": net, 
+        "trainloader": trainloader, 
+        "testloader": testloader,
+        "metrics_tracker": MetricsTracker(client_id, metrics_base_path), 
+        "client_id": client_id,
+    })
+    print(f"[Cliente {client_id}] inicializado com {len(trainloader.dataset)} amostras de treino.")
+
+# Cria a aplicação cliente
+app = ClientApp()
+
+@app.train()
+def train_fn(msg: Message, context: Context) -> Message:
+    """Treina o modelo localmente."""
+    # 🔧 faz um mapeamento partition-id para client_id
+    partition_id = int(context.node_config["partition-id"])
+    client_id = partition_id
+    
+    print(f"[DEBUG] Train - partition-id={partition_id} -> client_id={client_id}")
+
+    initialize_client_state(client_id, context)
+    
+    net = model_state["net"]
+    trainloader = model_state["trainloader"]
+    metrics_tracker = model_state["metrics_tracker"]
+    
+    # Obtém o próximo número de rodada do histórico
+    #round_num = metrics_tracker.get_next_round_number()
+    round_num = int(msg.content["config"].get("server-round", 0))
+    
+    print(f"\n[Node {context.node_id}, Cliente {client_id}] === Ronda de Treino {round_num} ===")
+    
+    arrays = msg.content["arrays"]
+    net.load_state_dict(arrays.to_torch_state_dict())
+    
+    # Lê configurações de treino do context
+    local_epochs = int(context.run_config.get("local-epochs", 1))
+    learning_rate = float(context.run_config.get("learning-rate", 1e-5))
+    max_grad_norm = float(context.run_config.get("max-grad-norm", 1.0))
+    save_checkpoint_every = int(context.run_config.get("save-checkpoint-every", 5))
+    
+    avg_train_loss = train(
+        net, 
+        trainloader, 
+        epochs=local_epochs, 
+        learning_rate=learning_rate,
+        max_grad_norm=max_grad_norm,
+        device=DEVICE
+    )
+    print(f"[Node {context.node_id}, Cliente {client_id}] Perda de treino: {avg_train_loss:.6f}")
+    
+    metrics_tracker.add_train_metrics(round_num, avg_train_loss)
+    if round_num % save_checkpoint_every == 0:
+        metrics_tracker.save_checkpoint(net, round_num)
+    metrics_tracker.save_metrics()
+    
+    model_record = ArrayRecord(net.state_dict())
+    metrics = MetricRecord({
+        "train_loss": avg_train_loss,
+        "num-examples": len(trainloader.dataset),
+        "client_id": client_id,
+    })
+    
+    content = RecordDict({"arrays": model_record, "metrics": metrics})
+    return Message(content=content, reply_to=msg)
+
+@app.evaluate()
+def evaluate_fn(msg: Message, context: Context) -> Message:
+    """Avalia o modelo localmente."""
+    
+    # partition-id para client_id
+    partition_id = int(context.node_config["partition-id"])
+    client_id = partition_id
+    
+    print(f"[DEBUG] Evaluate - partition-id={partition_id} -> client_id={client_id}")
+
+    initialize_client_state(client_id, context)
+
+    net = model_state["net"]
+    testloader = model_state["testloader"]
+    metrics_tracker = model_state["metrics_tracker"]
+    
+    # Usa o último número de rodada do histórico de treino
+    if metrics_tracker.history["train"]:
+        #round_num = metrics_tracker.history["train"][-1]["round"]
+        round_num = int(msg.content["config"].get("server-round", 0))
+    else:
+        round_num = 1
+    
+    arrays = msg.content["arrays"]
+    net.load_state_dict(arrays.to_torch_state_dict())
+    
+    loss, num_examples = test(net, testloader, device=DEVICE)
+    print(f"[Node {context.node_id}, Cliente {client_id}] Perda de validação: {loss:.6f}")
+    
+    metrics_tracker.add_eval_metrics(round_num, loss)
+    metrics_tracker.save_metrics()
+    
+    metrics = MetricRecord({
+        "eval_loss": loss,
+        "num-examples": num_examples,
+        "client_id": client_id,
+    })
+    
+    content = RecordDict({"metrics": metrics})
+    return Message(content=content, reply_to=msg)
+
+if __name__ == "__main__":
+    print("Cliente pronto para ser executado com Flower 1.22.0")
+    print("Use: flwr run . ou flower-supernode para deployment")

fleven/collector.py

@@ -0,0 +1,95 @@
+"""Coletor de métricas para análise de treinamento federado."""
+import numpy as np
+
+
+class MetricsCollector:
+    """Coleta e organiza métricas de treinamento e validação."""
+    
+    def __init__(self, strategy_name):
+        self.strategy_name = strategy_name
+        self.train_metrics_by_round = []
+        self.eval_metrics_by_round = []
+        
+        self.convergence_metrics = {
+            "rounds": [],
+            "loss_variance": [],
+            "loss_std": [],
+            "max_min_diff": []
+        }
+    
+    @property
+    def active_client_ids(self):
+        """
+        Inspeciona os dados coletados e retorna uma lista ordenada de 
+        IDs de clientes únicos que enviaram métricas.
+        """
+        ids = set()
+        all_metrics_by_round = self.train_metrics_by_round + self.eval_metrics_by_round
+        
+        for round_data in all_metrics_by_round:
+            for key in round_data.keys():
+                if key.startswith("client_"):
+                    # Extrai o número de 'client_X_...'
+                    try:
+                        client_id = int(key.split("_")[1])
+                        ids.add(client_id)
+                    except (ValueError, IndexError):
+                        # Ignora chaves que não seguem o padrão esperado
+                        continue
+                        
+        return sorted(list(ids))
+    
+    def add_train_round(self, round_num, metrics):
+        """Adiciona métricas de uma rodada de treinamento."""
+        round_data = {
+            "round": round_num,
+            "global_train_loss": metrics.get("global_train_loss", None),
+            "client_0_train_loss": metrics.get("client_0_train_loss", None),
+            "client_1_train_loss": metrics.get("client_1_train_loss", None),
+            "client_2_train_loss": metrics.get("client_2_train_loss", None),
+        }
+        self.train_metrics_by_round.append(round_data)
+    
+    def add_eval_round(self, round_num, metrics):
+        """Adiciona métricas de uma rodada de avaliação."""
+        round_data = {
+            "round": round_num,
+            "global_eval_loss": metrics.get("global_eval_loss", None),
+            "client_0_eval_loss": metrics.get("client_0_eval_loss", None),
+            "client_1_eval_loss": metrics.get("client_1_eval_loss", None),
+            "client_2_eval_loss": metrics.get("client_2_eval_loss", None),
+        }
+        self.eval_metrics_by_round.append(round_data)
+    
+    def calculate_convergence_metrics(self, client_losses):
+        """Calcula métricas de convergência entre clientes."""
+        if len(client_losses) > 0:
+            variance = np.var(client_losses)
+            std_dev = np.std(client_losses)
+            max_min_diff = max(client_losses) - min(client_losses)
+            return variance, std_dev, max_min_diff
+        return 0, 0, 0
+    
+    @property
+    def train_metrics(self):
+        """Retorna métricas de treino no formato para os gráficos."""
+        result = {
+            "rounds": [r["round"] for r in self.train_metrics_by_round],
+            "global_train_loss": [r["global_train_loss"] for r in self.train_metrics_by_round if r["global_train_loss"] is not None],
+            "client_0_train_loss": [r["client_0_train_loss"] for r in self.train_metrics_by_round if r["client_0_train_loss"] is not None],
+            "client_1_train_loss": [r["client_1_train_loss"] for r in self.train_metrics_by_round if r["client_1_train_loss"] is not None],
+            "client_2_train_loss": [r["client_2_train_loss"] for r in self.train_metrics_by_round if r["client_2_train_loss"] is not None],
+        }
+        return result
+    
+    @property
+    def eval_metrics(self):
+        """Retorna métricas de avaliação no formato para os gráficos."""
+        result = {
+            "rounds": [r["round"] for r in self.eval_metrics_by_round],
+            "global_eval_loss": [r["global_eval_loss"] for r in self.eval_metrics_by_round if r["global_eval_loss"] is not None],
+            "client_0_eval_loss": [r["client_0_eval_loss"] for r in self.eval_metrics_by_round if r["client_0_eval_loss"] is not None],
+            "client_1_eval_loss": [r["client_1_eval_loss"] for r in self.eval_metrics_by_round if r["client_1_eval_loss"] is not None],
+            "client_2_eval_loss": [r["client_2_eval_loss"] for r in self.eval_metrics_by_round if r["client_2_eval_loss"] is not None],
+        }
+        return result

fleven/mlflow_utils.py

@@ -0,0 +1,162 @@
+import mlflow
+from pathlib import Path
+from typing import Dict, Optional
+import torch
+
+"""Utilitários para integração com MLflow."""
+
+class MLflowTracker:
+    """Gerencia logging de experimentos com MLflow."""
+    
+    def __init__(self, tracking_uri: str, experiment_name: str, enabled: bool = True):
+        """
+        Inicializa o tracker do MLflow.
+        
+        Args:
+            tracking_uri: URI do servidor MLflow
+            experiment_name: Nome do experimento
+            enabled: Se True, habilita logging no MLflow
+        """
+        self.enabled = enabled
+        
+        if not self.enabled:
+            print("[MLflow] Tracking desabilitado")
+            return
+        
+        try:
+            mlflow.set_tracking_uri(tracking_uri)
+            mlflow.set_experiment(experiment_name)
+            self.experiment = mlflow.get_experiment_by_name(experiment_name)
+            print(f"[MLflow] Conectado ao experimento '{experiment_name}' em {tracking_uri}")
+        except Exception as e:
+            print(f"[MLflow] AVISO: Erro ao conectar: {e}")
+            self.enabled = False
+    
+    def start_run(self, run_name: str, tags: Optional[Dict] = None) -> Optional[mlflow.ActiveRun]:
+        """Inicia um novo run no MLflow."""
+        if not self.enabled:
+            return None
+        
+        try:
+            run = mlflow.start_run(run_name=run_name, tags=tags)
+            print(f"[MLflow] Run iniciado: {run_name} (ID: {run.info.run_id})")
+            return run
+        except Exception as e:
+            print(f"[MLflow] AVISO: Erro ao iniciar run: {e}")
+            return None
+    
+    def end_run(self):
+        """Finaliza o run atual."""
+        if not self.enabled:
+            return
+        
+        try:
+            mlflow.end_run()
+            print("[MLflow] Run finalizado")
+        except Exception as e:
+            print(f"[MLflow] AVISO: Erro ao finalizar run: {e}")
+    
+    def log_params(self, params: Dict):
+        """Loga parâmetros do experimento."""
+        if not self.enabled:
+            return
+        
+        try:
+            mlflow.log_params(params)
+            print(f"[MLflow] {len(params)} parâmetros logados")
+        except Exception as e:
+            print(f"[MLflow] AVISO: Erro ao logar parâmetros: {e}")
+    
+    def log_metric(self, key: str, value: float, step: Optional[int] = None):
+        """Loga uma métrica."""
+        if not self.enabled:
+            return
+        
+        try:
+            mlflow.log_metric(key, value, step=step)
+        except Exception as e:
+            print(f"[MLflow] AVISO: Erro ao logar métrica {key}: {e}")
+    
+    def log_metrics(self, metrics: Dict, step: Optional[int] = None):
+        """Loga múltiplas métricas."""
+        if not self.enabled:
+            return
+        
+        try:
+            mlflow.log_metrics(metrics, step=step)
+        except Exception as e:
+            print(f"[MLflow] AVISO: Erro ao logar métricas: {e}")
+    
+    def log_artifact(self, local_path: str):
+        """Loga um arquivo como artifact."""
+        if not self.enabled:
+            return
+        
+        try:
+            mlflow.log_artifact(local_path)
+            print(f"[MLflow] Artifact logado: {local_path}")
+        except Exception as e:
+            print(f"[MLflow] AVISO: Erro ao logar artifact: {e}")
+    
+    def log_artifacts(self, local_dir: str):
+        """Loga um diretório inteiro como artifacts."""
+        if not self.enabled:
+            return
+        
+        try:
+            mlflow.log_artifacts(local_dir)
+            print(f"[MLflow] Artifacts logados do diretório: {local_dir}")
+        except Exception as e:
+            print(f"[MLflow] AVISO: Erro ao logar artifacts: {e}")
+    
+    def log_model(self, model: torch.nn.Module, artifact_path: str = "model"):
+        """Loga o modelo PyTorch."""
+        if not self.enabled:
+            return
+        
+        try:
+            mlflow.pytorch.log_model(model, artifact_path)
+            print(f"[MLflow] Modelo PyTorch logado em '{artifact_path}'")
+        except Exception as e:
+            print(f"[MLflow] AVISO: Erro ao logar modelo: {e}")
+    
+    def set_tag(self, key: str, value: str):
+        """Define uma tag para o run."""
+        if not self.enabled:
+            return
+        
+        try:
+            mlflow.set_tag(key, value)
+        except Exception as e:
+            print(f"[MLflow] AVISO: Erro ao definir tag: {e}")
+    
+    def set_tags(self, tags: Dict[str, str]):
+        """Define múltiplas tags."""
+        if not self.enabled:
+            return
+        
+        try:
+            mlflow.set_tags(tags)
+        except Exception as e:
+            print(f"[MLflow] AVISO: Erro ao definir tags: {e}")
+
+
+def get_mlflow_tracker(context) -> MLflowTracker:
+    """
+    Cria um MLflowTracker a partir do contexto do Flower.
+    
+    Args:
+        context: Context do Flower contendo configurações
+        
+    Returns:
+        Instância de MLflowTracker
+    """
+    mlflow_enabled = context.run_config.get("mlflow-enable", True)
+    tracking_uri = context.run_config.get("mlflow-tracking-uri", "http://127.0.0.1:5000")
+    experiment_name = context.run_config.get("mlflow-experiment-name", "FLEVEn-Experiments")
+    
+    return MLflowTracker(
+        tracking_uri=tracking_uri,
+        experiment_name=experiment_name,
+        enabled=mlflow_enabled
+    )

fleven/server.py

@@ -0,0 +1,358 @@
+"""ServerApp para aprendizado federado com FLEVEn."""
+import torch
+from typing import Iterable, Optional
+from pathlib import Path
+from datetime import datetime
+
+from flwr.app import Context, ArrayRecord, MetricRecord
+from flwr.serverapp import ServerApp, Grid
+from flwr.serverapp.strategy import FedAvg, FedAdam, FedYogi, FedAdagrad
+from flwr.common import Message
+
+from fleven.utils import set_seed, get_model
+from fleven.collector import MetricsCollector
+from fleven.analysis import create_visualizations, save_detailed_metrics, print_final_summary
+from fleven.mlflow_utils import get_mlflow_tracker  #   import do fmlfow
+
+STRATEGIES = {
+    "fedavg": FedAvg,
+    "fedadam": FedAdam,
+    "fedyogi": FedYogi,
+    "fedadagrad": FedAdagrad,
+}
+
+
+def get_custom_strategy_class(base_strategy_class):
+    """Cria dinamicamente uma classe CustomStrategy que herda da estratégia base."""
+    
+    class CustomStrategy(base_strategy_class):
+        def __init__(self, collector: MetricsCollector, mlflow_tracker=None, **kwargs):
+            super().__init__(**kwargs)
+            self.collector = collector
+            self.mlflow_tracker = mlflow_tracker  #   Adicionar tracker
+            strategy_name = self.__class__.__bases__[0].__name__
+            print(f"CustomStrategy (coletando métricas para {strategy_name}) inicializada.")
+
+        def aggregate_train(self, server_round: int, replies: Iterable[Message]) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+            aggregated_arrays, aggregated_metrics = super().aggregate_train(server_round, replies)
+            
+            if aggregated_metrics:
+                individual_losses = {}
+                for reply in replies:
+                    if reply.has_content() and "metrics" in reply.content:
+                        metrics = reply.content["metrics"]
+                        client_id = int(metrics.get("client_id", 0))
+                        train_loss = float(metrics.get("train_loss", 0.0))
+                        print(f"    > Detalhe Cliente {client_id}: Perda de Treino = {train_loss:.6f}")
+                        individual_losses[f"client_{client_id}_train_loss"] = train_loss
+                        
+                        #   Log no MLflow - métricas individuais
+                        if self.mlflow_tracker:
+                            self.mlflow_tracker.log_metric(
+                                f"client_{client_id}/train_loss",
+                                train_loss,
+                                step=server_round
+                            )
+                
+                global_loss = aggregated_metrics.get("train_loss")
+                metrics_dict = {"global_train_loss": global_loss}
+                metrics_dict.update(individual_losses)
+                self.collector.add_train_round(server_round, metrics_dict)
+                
+                #   Log no MLflow - métrica global
+                if self.mlflow_tracker and global_loss is not None:
+                    self.mlflow_tracker.log_metric(
+                        "global/train_loss",
+                        global_loss,
+                        step=server_round
+                    )
+
+            return aggregated_arrays, aggregated_metrics
+
+        def aggregate_evaluate(self, server_round: int, replies: Iterable[Message]) -> Optional[MetricRecord]:
+            aggregated_metrics = super().aggregate_evaluate(server_round, replies)
+            
+            if aggregated_metrics:
+                individual_losses = {}
+                for reply in replies:
+                    if reply.has_content() and "metrics" in reply.content:
+                        metrics = reply.content["metrics"]
+                        client_id = int(metrics.get("client_id", 0))
+                        eval_loss = float(metrics.get("eval_loss", 0.0))
+                        print(f"    > Detalhe Cliente {client_id}: Perda de Avaliação = {eval_loss:.6f}")
+                        individual_losses[f"client_{client_id}_eval_loss"] = eval_loss
+                        
+                        # Log no MLflow - métricas individuais
+                        if self.mlflow_tracker:
+                            self.mlflow_tracker.log_metric(
+                                f"client_{client_id}/eval_loss",
+                                eval_loss,
+                                step=server_round
+                            )
+                
+                global_loss = aggregated_metrics.get("eval_loss")
+                metrics_dict = {"global_eval_loss": global_loss}
+                metrics_dict.update(individual_losses)
+                self.collector.add_eval_round(server_round, metrics_dict)
+                
+                #   Log no MLflow - métrica global
+                if self.mlflow_tracker and global_loss is not None:
+                    self.mlflow_tracker.log_metric(
+                        "global/eval_loss",
+                        global_loss,
+                        step=server_round
+                    )
+
+            return aggregated_metrics
+
+    return CustomStrategy
+
+
+# Cria a aplicação servidor
+app = ServerApp()
+
+@app.main()
+def main(grid: Grid, context: Context) -> None:
+    """Função principal do servidor - lê todas as configurações do Context."""
+
+    mlflow_tracker = get_mlflow_tracker(context)
+    
+    seed = int(context.run_config.get("seed", 42))
+    set_seed(seed)
+    
+    # 🔧 configs gerais
+    strategy_name = context.run_config.get("strategy", "fedavg").lower()
+    num_rounds = int(context.run_config.get("rounds", 5))
+    min_nodes = int(context.run_config.get("min-nodes", 3))
+    
+    
+    # 🔧 Configurações do modelo
+    model_type = context.run_config.get("model-type", "lstm")
+    input_size = int(context.run_config.get("input-size", 6))
+    prediction_length = int(context.run_config.get("prediction-length", 10))
+    num_layers = int(context.run_config.get("num-layers", 1))
+    sequence_length = int(context.run_config.get("sequence-length", 60))
+    target_column = str(context.run_config.get("target-column", "P_kW"))
+    
+    # Parâmetros para "lstm" e "mlp"
+    hidden_size = int(context.run_config.get("hidden-size", 32))
+    
+    # Parâmetros para "lstm_dense" (o novo modelo adaptado)
+    lstm_hidden_size = int(context.run_config.get("lstm-hidden-size", 32))
+    dense_hidden_size = int(context.run_config.get("dense-hidden-size", 16))
+    
+    # Parâmetro de Dropout para "lstm" e "lstm_dense"
+    dropout = float(context.run_config.get("dropout", 0.0))
+    
+    # --- FIM DA ALTERAÇÃO 1 ---
+
+    # Configurações de treino
+    batch_size = int(context.run_config.get("batch-size", 32))
+    learning_rate = float(context.run_config.get("learning-rate", 1e-5))
+    local_epochs = int(context.run_config.get("local-epochs", 1))
+    train_test_split = float(context.run_config.get("train-test-split", 0.8))
+    
+    # 🔧 Caminho para salvar resultados
+    results_base_path = context.run_config.get("results-base-path", None)
+    if results_base_path:
+        output_dir = Path(results_base_path)
+    else:
+        base_dir = Path(__file__).parent.parent
+        output_dir = base_dir / "results"
+    
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    #   Inicia run no MLflow
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    run_name = f"{strategy_name}_{model_type}_{timestamp}"
+    
+    mlflow_tracker.start_run(
+        run_name=run_name,
+        tags={
+            "strategy": strategy_name,
+            "model_type": model_type,
+            "target": target_column
+        }
+    )
+        
+    #   Log dos parâmetros no MLflow
+    mlflow_tracker.log_params({
+        "strategy": strategy_name,
+        "num_rounds": num_rounds,
+        "min_nodes": min_nodes,
+        "model_type": model_type,
+        "input_size": input_size,
+        "prediction_length": prediction_length,
+        "num_layers": num_layers,
+        "sequence_length": sequence_length,
+        "target_column": target_column,
+        "batch_size": batch_size,
+        "learning_rate": learning_rate,
+        "local_epochs": local_epochs,
+        "train_test_split": train_test_split,
+        "seed": seed,
+        
+        # Novos parâmetros
+        "hidden_size": hidden_size,
+        "lstm_hidden_size": lstm_hidden_size,
+        "dense_hidden_size": dense_hidden_size,
+        "dropout": dropout
+    })
+    
+    print(f"\n{'='*60}")
+    print(f"SERVIDOR DE APRENDIZADO FEDERADO")
+    print(f"{'='*60}")
+    print(f"Estratégia: {strategy_name.upper()}")
+    print(f"Rodadas: {num_rounds}")
+    print(f"Nós mínimos: {min_nodes}")
+    print(f"Modelo: {model_type.upper()}")
+    print(f"Tamanho da Previsão: {prediction_length}")
+    print(f"Tamanho Hidden (lstm/mlp): {hidden_size}")
+    print(f"Tamanho LSTM Hidden (lstm_dense): {lstm_hidden_size}")
+    print(f"Tamanho Dense Hidden (lstm_dense): {dense_hidden_size}")
+    print(f"Número de Camadas do Modelo: {num_layers}")
+    print(f"Dropout: {dropout}")
+    print(f"Target Column: {target_column}")
+    print(f"Resultados serão salvos em: {output_dir.absolute()}")
+    print(f"{'='*60}\n")
+    
+    # 🔧 Cria coletor de métricas
+    collector = MetricsCollector(strategy_name)
+    
+    # 🔧 Cria o dicionário de configuração do modelo
+    model_config = {
+        "name": model_type,
+        "input_size": input_size,
+        "output_size": prediction_length,
+        "num_layers": num_layers,
+        "sequence_length": sequence_length,
+        
+        # Parâmetros para "lstm" e "mlp"
+        "hidden_size": hidden_size,
+        
+        # Parâmetros para "lstm_dense"
+        "lstm_hidden_size": lstm_hidden_size,
+        "dense_hidden_size": dense_hidden_size,
+        
+        # Parâmetro de Dropout
+        "dropout": dropout
+    }
+    
+    # 🔧 Cria modelo inicial
+    net = get_model(model_config)
+    initial_arrays = ArrayRecord(net.state_dict())
+    
+    # 🔧 Parâmetros base para a estratégia
+    strategy_params = {
+        "fraction_train": 1.0,
+        "fraction_evaluate": 1.0,
+        "min_available_nodes": min_nodes,
+        "min_train_nodes": min_nodes,
+        "min_evaluate_nodes": min_nodes,
+    }
+
+    # 🔧 Carrega parâmetros específicos da estratégia
+    strategy_specific_params = context.run_config.get("strategy-params", {})
+
+    if strategy_name == "fedadam":
+        strategy_params["eta"] = float(strategy_specific_params.get("eta", 0.01))
+        strategy_params["beta_1"] = float(strategy_specific_params.get("beta_1", 0.9))
+        strategy_params["beta_2"] = float(strategy_specific_params.get("beta_2", 0.999))
+        print(f"Carregando FedAdam com: eta={strategy_params['eta']}, beta_1={strategy_params['beta_1']}, beta_2={strategy_params['beta_2']}")
+        
+        #   Log parâmetros específicos da estratégia
+        mlflow_tracker.log_params({
+            "eta": strategy_params["eta"],
+            "beta_1": strategy_params["beta_1"],
+            "beta_2": strategy_params["beta_2"]
+        })
+    
+    elif strategy_name == "fedadagrad":
+        strategy_params["eta"] = float(strategy_specific_params.get("eta_adagrad", 0.1))
+        strategy_params["initial_accumulator_value"] = float(strategy_specific_params.get("initial_accumulator_value", 0.1))
+        print(f"Carregando FedAdagrad com: eta={strategy_params['eta']}, initial_accumulator_value={strategy_params['initial_accumulator_value']}")
+        
+        mlflow_tracker.log_params({
+            "eta": strategy_params["eta"],
+            "initial_accumulator_value": strategy_params["initial_accumulator_value"]
+        })
+
+    elif strategy_name == "fedyogi":
+        strategy_params["eta"] = float(strategy_specific_params.get("eta_yogi", 0.01))
+        strategy_params["beta_1"] = float(strategy_specific_params.get("beta_1_yogi", 0.9))
+        strategy_params["beta_2"] = float(strategy_specific_params.get("beta_2_yogi", 0.999))
+        strategy_params["initial_accumulator_value"] = float(strategy_specific_params.get("initial_accumulator_value_yogi", 1e-6))
+        print(f"Carregando FedYogi com: eta={strategy_params['eta']}, beta_1={strategy_params['beta_1']}, beta_2={strategy_params['beta_2']}")
+        
+        mlflow_tracker.log_params({
+            "eta": strategy_params["eta"],
+            "beta_1": strategy_params["beta_1"],
+            "beta_2": strategy_params["beta_2"],
+            "initial_accumulator_value": strategy_params["initial_accumulator_value"]
+        })
+
+    # 🔧 Instancia a estratégia de forma dinâmica
+    BaseStrategyClass = STRATEGIES.get(strategy_name, FedAvg)
+    CustomStrategyClass = get_custom_strategy_class(BaseStrategyClass)
+    strategy = CustomStrategyClass(
+        collector=collector,
+        mlflow_tracker=mlflow_tracker,  #   Passar tracker para a estratégia
+        **strategy_params
+    )
+    
+    print("Iniciando servidor FL...")
+    
+    # 🔧 Inicia o treino federado
+    result = strategy.start(
+        grid=grid,
+        initial_arrays=initial_arrays,
+        num_rounds=num_rounds,
+    )
+    
+    # 🔧 Imprime informações sobre o resultado final
+    print("\n" + "="*60)
+    if result.arrays:
+        print(f"Modelo final obtido com sucesso!")
+        total_params = sum(p.numel() for p in result.arrays.to_torch_state_dict().values())
+        print(f"Total de parâmetros: {total_params}")
+        
+        #   Log do modelo final no MLflow
+        final_model = get_model(model_config)
+        final_model.load_state_dict(result.arrays.to_torch_state_dict())
+        mlflow_tracker.log_model(final_model, "final_model")
+        
+        #   Salvar modelo final localmente e logar como artifact
+        model_path = output_dir / "final_model.pt"
+        torch.save(final_model.state_dict(), model_path)
+        mlflow_tracker.log_artifact(str(model_path))
+    
+    print(f"Resultados salvos em: {output_dir.absolute()}")
+    print("="*60)
+
+    # 🔧 Gera análises e visualizações
+    print("\nTREINAMENTO CONCLUÍDO - GERANDO ANÁLISES")
+    print("="*60)
+    
+    try:
+        create_visualizations(collector, output_dir)
+        save_detailed_metrics(collector, output_dir)
+        print_final_summary(collector)
+        
+        #   Log dos artifacts (gráficos, CSVs, etc.) no MLflow
+        mlflow_tracker.log_artifacts(str(output_dir))
+        
+    except Exception as e:
+        print(f"AVISO: Erro ao gerar análises: {e}")
+        print("O treinamento foi concluído com sucesso, mas as visualizações não foram geradas.")
+    
+    #   Finaliza o run do MLflow
+    mlflow_tracker.end_run()
+    
+    print("\n" + "="*60)
+    print("PROCESSAMENTO FINALIZADO")
+    print("="*60)
+
+
+if __name__ == "__main__":
+    print("Servidor pronto para ser executado com Flower 1.22.0")
+    print("Use: flwr run .")

fleven/utils.py

@@ -0,0 +1,284 @@
+import pandas as pd
+import numpy as np
+import random
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import TensorDataset, DataLoader
+from sklearn.preprocessing import MinMaxScaler
+from pathlib import Path
+
+def set_seed(seed: int):
+    """Seeds para reprodutibilidade."""
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+# LSTM
+class LSTMNet(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size, num_layers=1, dropout=0.0):
+        super(LSTMNet, self).__init__()
+        self.lstm = nn.LSTM(
+            input_size, 
+            hidden_size, 
+            num_layers, 
+            batch_first=True,
+            # Dropout entre camadas LSTM empilhadas (se num_layers > 1)
+            dropout=dropout if num_layers > 1 else 0.0
+        )
+        self.linear = nn.Linear(hidden_size, output_size)
+
+    def forward(self, x):
+        lstm_out, _ = self.lstm(x)
+        last_time_step_out = lstm_out[:, -1, :]
+        out = self.linear(last_time_step_out)
+        return out
+    
+# LSTM -> Dropout -> Dense(ReLU) -> Dense(Output)
+class LSTMDenseNet(nn.Module):
+    def __init__(self, input_size, lstm_hidden_size, dense_hidden_size, output_size, num_layers=1, dropout=0.0):
+        super(LSTMDenseNet, self).__init__()
+        self.lstm = nn.LSTM(
+            input_size, 
+            lstm_hidden_size, 
+            num_layers, 
+            batch_first=True,
+            dropout=dropout if num_layers > 1 else 0.0
+        )
+        # Dropout aplicado à saída da camada LSTM
+        self.dropout = nn.Dropout(dropout)
+        self.fc1 = nn.Linear(lstm_hidden_size, dense_hidden_size)
+        self.fc2 = nn.Linear(dense_hidden_size, output_size)
+
+    def forward(self, x):
+        # lstm_out shape: (batch_size, seq_len, lstm_hidden_size)
+        lstm_out, _ = self.lstm(x)
+        
+        # saída do último passo de tempo
+        # (batch_size, lstm_hidden_size)
+        last_time_step_out = lstm_out[:, -1, :]
+        
+        # Aplica dropout
+        out = self.dropout(last_time_step_out)
+        
+        # Passa pelas camadas densas
+        out = self.fc1(out)
+        out = F.relu(out) # Aplicando ReLU como no notebook
+        out = self.fc2(out)
+        return out
+
+# MLP
+class MLPNet(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size):
+        super(MLPNet, self).__init__()
+        # O input será a sequência achatada
+        self.fc1 = nn.Linear(input_size, hidden_size)
+        self.relu = nn.ReLU()
+        self.fc2 = nn.Linear(hidden_size, output_size)
+
+    def forward(self, x):
+        # deforma/achata o input de (batch, sequence_length, features) para (batch, sequence_length * features)
+        batch_size = x.shape[0]
+        x_flat = x.view(batch_size, -1)
+        
+        out = self.fc1(x_flat)
+        out = self.relu(out)
+        out = self.fc2(out)
+        return out
+
+def create_sliding_windows(data, sequence_length, prediction_length):
+    """Cria janelas deslizantes para problemas de séries temporais."""
+    xs, ys = [], []
+    for i in range(len(data) - sequence_length - prediction_length + 1):
+        x = data[i:(i + sequence_length)]
+        y = data[(i + sequence_length):(i + sequence_length + prediction_length), -1]
+        xs.append(x)
+        ys.append(y)
+    return np.array(xs), np.array(ys)
+
+def load_data(client_id: int, sequence_length: int, prediction_length: int, 
+              batch_size: int, train_test_split: float, data_base_path: str = None,
+              target_column: str = "P_kW"):
+    """
+    Carrega os dados para um cliente específico, processa e retorna DataLoaders.
+    
+    Args:
+        client_id: ID do cliente
+        sequence_length: Tamanho da janela de entrada
+        prediction_length: Número de passos à frente para prever
+        batch_size: Tamanho do batch
+        train_test_split: Proporção de dados para treino (ex: 0.8 = 80%)
+        data_base_path: Caminho base para os dados (opcional),
+        target_column: O nome da coluna a ser usada como alvo da previsão
+    """
+    # 🔧 Define o diretório de dados de forma robusta
+    if data_base_path:
+        # Usa o caminho configurado
+        data_dir = Path(data_base_path) / f"client_{client_id}"
+        print(f"[Cliente {client_id}] Usando data_base_path configurado: {data_dir}")
+    else:
+        # Usa caminho relativo ao arquivo atual
+        base_dir = Path(__file__).parent.parent
+        data_dir = base_dir / "data" / f"client_{client_id}"
+        print(f"[Cliente {client_id}] Usando caminho relativo: {data_dir}")
+    
+    print(f"[Cliente {client_id}] Procurando dados em: {data_dir.absolute()}")
+    
+    # Verifica se o diretório existe
+    if not data_dir.exists():
+        raise FileNotFoundError(
+            f"Diretório não encontrado para o cliente {client_id}: {data_dir.absolute()}"
+        )
+    
+    # Carrega todos os arquivos CSV do diretório
+    csv_files = list(data_dir.glob("*.csv"))
+    
+    if not csv_files:
+        raise FileNotFoundError(
+            f"Nenhum arquivo CSV encontrado para o cliente {client_id} no diretório {data_dir.absolute()}"
+        )
+    
+    print(f"[Cliente {client_id}] Encontrados {len(csv_files)} arquivos CSV")
+    all_routes_df = [pd.read_csv(f) for f in csv_files]
+    combined_df = pd.concat(all_routes_df, ignore_index=True)
+
+    all_columns = ['vehicle_speed', 'engine_rpm', 'P_kW']
+    
+    # se a coluna alvo existe
+    if target_column not in all_columns:
+        raise ValueError(
+            f"A coluna alvo '{target_column}' não é uma das colunas válidas: {all_columns}"
+        )
+    
+    # Reordena as colunas para garantir que a coluna alvo seja a ÚLTIMA
+    feature_columns = [col for col in all_columns if col != target_column] + [target_column]
+    processed_df = combined_df[feature_columns].dropna()
+
+    split_index = int(len(processed_df) * train_test_split)
+    train_df = processed_df.iloc[:split_index]
+    test_df = processed_df.iloc[split_index:]
+
+    scaler = MinMaxScaler()
+    scaler.fit(train_df)
+
+    train_scaled = scaler.transform(train_df)
+    test_scaled = scaler.transform(test_df)
+
+    X_train, y_train = create_sliding_windows(train_scaled, sequence_length, prediction_length)
+    X_test, y_test = create_sliding_windows(test_scaled, sequence_length, prediction_length)
+    
+    if len(X_train) == 0 or len(X_test) == 0:
+        raise ValueError(
+            f"A divisão de dados para o cliente {client_id} resultou em um conjunto vazio."
+        )
+
+    X_train_tensor = torch.from_numpy(X_train).float()
+    y_train_tensor = torch.from_numpy(y_train).float()
+    X_test_tensor = torch.from_numpy(X_test).float()
+    y_test_tensor = torch.from_numpy(y_test).float()
+
+    train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
+    test_dataset = TensorDataset(X_test_tensor, y_test_tensor)
+    
+    trainloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+    testloader = DataLoader(test_dataset, batch_size=batch_size)
+    
+    num_features = X_train_tensor.shape[2]
+    
+    print(f"[Cliente {client_id}] Dados carregados: {len(train_dataset)} treino, {len(test_dataset)} teste")
+
+    return trainloader, testloader, num_features
+
+def train(net, trainloader, epochs: int, learning_rate: float, 
+          max_grad_norm: float, device):
+    """Treina e retorna a perda média por amostra."""
+    criterion = torch.nn.MSELoss(reduction="mean")
+    optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)
+    net.to(device)
+    net.train()
+
+    total_loss_sum = 0.0
+    total_samples = 0
+
+    for _ in range(epochs):
+        for sequences, labels in trainloader:
+            sequences, labels = sequences.to(device), labels.to(device)
+            optimizer.zero_grad()
+            outputs = net(sequences)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(net.parameters(), max_norm=max_grad_norm)
+            optimizer.step()
+
+            batch_size = sequences.size(0)
+            total_loss_sum += loss.item() * batch_size
+            total_samples += batch_size
+
+    if total_samples == 0:
+        return 0.0
+    return total_loss_sum / total_samples
+
+
+def test(net, testloader, device):
+    """Avalia e retorna (avg_loss_per_sample, num_examples)."""
+    criterion = torch.nn.MSELoss(reduction="mean")
+    net.to(device)
+    net.eval()
+    total_loss_sum = 0.0
+    total_samples = 0
+    with torch.no_grad():
+        for sequences, labels in testloader:
+            sequences, labels = sequences.to(device), labels.to(device)
+            outputs = net(sequences)
+            loss = criterion(outputs, labels)
+            batch_size = sequences.size(0)
+            total_loss_sum += loss.item() * batch_size
+            total_samples += batch_size
+
+    if total_samples == 0:
+        return 0.0, 0
+    avg_loss = total_loss_sum / total_samples
+    return avg_loss, total_samples
+
+def get_model(model_config: dict):
+    """
+    Fábrica de modelos que retorna uma instância de modelo com base na configuração.
+    """
+    model_type = model_config.get("name", "lstm").lower()
+    
+    if model_type == "lstm":
+        print(f"Criando modelo LSTMNet (Simples: LSTM -> Linear)...")
+        # Modelo original do projeto, agora com dropout
+        return LSTMNet(
+            input_size=model_config["input_size"],
+            hidden_size=model_config["hidden_size"], # Usa 'hidden_size'
+            output_size=model_config["output_size"],
+            num_layers=model_config.get("num_layers", 1),
+            dropout=model_config.get("dropout", 0.0)
+        )
+    
+    elif model_type == "lstm_dense":
+        print(f"Criando modelo LSTMDenseNet (Adaptado: LSTM -> Dense -> Linear)...")
+        # modelo adaptado de um dos notebook do DACAI
+        return LSTMDenseNet(
+            input_size=model_config["input_size"],
+            lstm_hidden_size=model_config["lstm_hidden_size"],   # <-- Novo parâmetro pro pyproject tbm
+            dense_hidden_size=model_config["dense_hidden_size"], # <-- Novo parâmetro pro pyproject tbm
+            output_size=model_config["output_size"],
+            num_layers=model_config.get("num_layers", 1),
+            dropout=model_config.get("dropout", 0.0)
+        )
+
+    elif model_type == "mlp":
+        print(f"Criando modelo MLPNet...")
+        # Para o MLP, o tamanho da entrada é a sequência inteira achatada
+        mlp_input_size = model_config["sequence_length"] * model_config["input_size"]
+        return MLPNet(
+            input_size=mlp_input_size,
+            hidden_size=model_config["hidden_size"], # Usa 'hidden_size'
+            output_size=model_config["output_size"]
+        )
+    else:
+        raise ValueError(f"Tipo de modelo desconhecido: {model_type}")

pyproject.toml

@@ -0,0 +1,149 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fleven"
+version = "1.0.0"
+description = "FLEVEn — Federated Learning for Vehicular Environment"
+
+readme = "README.md"
+keywords = ["federated-learning", "flower", "mlflow", "federated-learning-vehicular", "time-series", "lstm", "pytorch", "obd"]
+classifiers = [
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules"
+]
+authors = [
+    {name = "João C. Braz", email = "calbraz@gmail.com"},
+    {name = "José Wilson C. Souza", email = "josewilson@matematica.ufrj.br"},
+    {name = "Erick de Souza Lima", email = "erickcefetbcc@gmail.com"},
+    {name = "Mina", email = "minammonteiro4@gmail.com"},
+]
+
+maintainers = [
+    {name = "José Wilson C. Souza", email = "josewilson@matematica.ufrj.br"}
+]
+
+license = {text = "Apache-2.0"}
+dependencies = [
+    "flwr[simulation]>=1.22.0,<2.0",
+    "torch>=2.0.0",
+    "pandas>=2.0.0",
+    "numpy>=1.24.0",
+    "scikit-learn>=1.3.0",
+    "matplotlib>=3.7.0",
+    "seaborn>=0.12.0",
+    "toml",
+    "mlflow>=2.9.0"
+]
+
+[project.urls]
+Repository = "https://github.com/josewilsonsouza/fleven"
+"Issue Tracker" = "https://github.com/josewilsonsouza/fleven/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["fleven"]
+
+[tool.flwr.app]
+publisher = "Lainf_Dmtic_Inmetro"
+
+[tool.flwr.app.components]
+serverapp = "fleven.server:app"
+clientapp = "fleven.client:app"
+
+[tool.flwr.app.config]
+# Configurações de Federação
+strategy = "fedavg"  # Opções: "fedavg", "fedadam", "fedadagrad", "fedyogi"
+rounds = 10
+min-nodes = 3
+seed = 42
+
+# 🔧 Caminhos (ajustar conforme necessário). (deixar só "" parece que funciona)
+data-base-path = "" #"C:/Users/abece/Documents/fleven-test/data"
+metrics-base-path = "" #"C:/Users/abece/Documents/fleven-test/metrics"
+results-base-path = "" #"C:/Users/abece/Documents/fleven-test/results"
+
+# Configurações MLflow
+mlflow-tracking-uri = "http://127.0.0.1:5000"  # URI do servidor MLflow
+mlflow-experiment-name = "FLEVEn-Experiments"
+mlflow-enable = true  # Habilitar/desabilitar MLflow
+
+
+# Escolha dos modelos do FLEVEn: "lstm", "lstm_dense", "mlp"
+model-type = "lstm_dense"
+
+# Parâmetros para "lstm" e "mlp"
+hidden-size = 32
+
+# Parâmetros para "lstm_dense" (o novo modelo adaptado)
+lstm-hidden-size = 32  # Tamanho da camada LSTM
+dense-hidden-size = 16 # Tamanho da camada Densa intermediária
+
+# Parâmetros para "lstm" e "lstm_dense"
+input-size = 3
+num-layers = 1
+dropout = 0.2  # Taxa de dropout (0.0 para desativar)
+
+# Configurações de Séries Temporais
+sequence-length = 100
+prediction-length = 50
+target-column = "vehicle_speed"
+
+# Configurações de Treinamento
+batch-size = 32
+learning-rate = 1e-5
+local-epochs = 1
+max-grad-norm = 1.0
+
+# Configurações de Dados
+train-test-split = 0.8
+
+# Configurações de Checkpoint
+save-checkpoint-every = 5
+
+[tool.flwr.app.config.strategy-params]
+# Parâmetros para FedAdam
+eta = 0.01
+beta_1 = 0.9
+beta_2 = 0.999
+
+# Parâmetros para FedAdagrad
+eta_adagrad = 0.1
+initial_accumulator_value = 0.1
+
+# Parâmetros para FedYogi
+eta_yogi = 0.01
+beta_1_yogi = 0.9
+beta_2_yogi = 0.999
+initial_accumulator_value_yogi = 1e-6
+
+[tool.flwr.federations]
+default = "local-simulation"
+
+[tool.flwr.federations.local-simulation]
+options.num-supernodes = 3
+options.backend.client-resources.num-cpus = 2
+options.backend.client-resources.num-gpus = 0.0
+
+# essas configs vão ser importantes mais na frente, quando quisermos, 
+# por exemplo, outros parametros para certos clients
+#[[tool.flwr.federations.local-simulation.options.supernode.resources]]
+#node-config.partition-id = 1
+#node-config.num-partitions = 3
+
+#[[tool.flwr.federations.local-simulation.options.supernode.resources]]
+#node-config.partition-id = 2
+#node-config.num-partitions = 3
+
+#[[tool.flwr.federations.local-simulation.options.supernode.resources]]
+#node-config.partition-id = 3
+#node-config.num-partitions = 3
+
+[tool.flwr.federations.fleven-deployment]
+address = "127.0.0.1:9093"
+insecure = true