Upload 13 files

README

@@ -0,0 +1,306 @@
+# Federated Learning para Previsão de Consumo de Combustível
+
+Sistema de Aprendizado Federado (FL) para prever consumo de combustível usando dados de sensores OBD de diferentes veículos, mantendo a privacidade dos dados em cada cliente.
+
+## 📋 Visão Geral
+
+Este projeto implementa um sistema de Aprendizado Federado usando o framework Flower, onde:
+- **3 clientes** (Ubuntu) representam diferentes veículos com seus dados locais
+- **1 servidor** (Windows) coordena o treinamento sem acessar os dados brutos
+- Modelo LSTM para previsão de séries temporais de consumo (P_kW)
+- Múltiplas estratégias de agregação: FedAvg, FedAdam, FedYogi, FedAdagrad
+
+## 🏗️ Arquitetura do Sistema
+
+```
+┌─────────────────┐
+│  Servidor (Win) │
+│   16GB RAM      │
+│   Porta: 8080   │
+└────────┬────────┘
+         │
+    ┌────┴────┬──────────┐
+    │         │          │
+┌───▼───┐ ┌──▼───┐ ┌────▼───┐
+│Cliente│ │Cliente│ │Cliente │
+│   1   │ │   2  │ │   3    │
+│Ubuntu │ │Ubuntu│ │Ubuntu  │
+│ 8GB   │ │ 8GB  │ │  8GB   │
+└───────┘ └──────┘ └────────┘
+```
+
+## 📁 Estrutura do Projeto
+
+```
+fl_project/
+├── data/                    # Dados dos veículos (não versionado)
+│   ├── client_1/           # Percursos do veículo 1
+│   │   ├── percurso_1.csv
+│   │   ├── percurso_2.csv
+│   │   └── ...
+│   ├── client_2/           # Percursos do veículo 2
+│   └── client_3/           # Percursos do veículo 3
+├── server.py               # Código do servidor FL
+├── client.py               # Código dos clientes FL
+├── utils.py                # Modelo LSTM e funções auxiliares
+├── analysis_tool.py        # Ferramenta de análise pós-treinamento
+├── run.sh                  # Script para execução local
+├── run_all_strategies.sh   # Script para testar todas as estratégias
+├── requirements.txt        # Dependências Python
+└── README.md              # Este arquivo
+```
+
+## 🔧 Requisitos do Sistema
+
+### Hardware Mínimo
+- **Servidor**: 8GB RAM (recomendado 16GB)
+- **Clientes**: 4GB RAM cada (recomendado 8GB)
+- **Rede**: Conexão estável entre servidor e clientes
+
+### Software
+- **Python**: 3.10 - 3.11
+- **Sistema Operacional**:
+  - Servidor: Windows 10/11 ou Linux
+  - Clientes: Ubuntu 20.04/22.04
+
+## 📦 Instalação
+
+### 1. Clone o Repositório
+
+```bash
+git clone https://github.com/seu-usuario/fl_project.git
+cd fl_project
+```
+
+### 2. Crie um Ambiente Virtual
+
+**No Ubuntu (Clientes):**
+```bash
+python3 -m venv venv
+source venv/bin/activate
+```
+
+**No Windows (Servidor):**
+```powershell
+python -m venv venv
+.\venv\Scripts\activate
+```
+
+### 3. Instale as Dependências
+
+```bash
+pip install -r requirements.txt
+```
+
+### 4. Prepare os Dados
+
+Organize os dados de cada veículo na estrutura:
+```
+data/
+├── client_1/  # Dados do veículo 1
+├── client_2/  # Dados do veículo 2
+└── client_3/  # Dados do veículo 3
+```
+
+**Formato esperado dos CSVs:**
+- Colunas principais: `vehicle_speed`, `engine_rpm`, `accel_x`, `accel_y`, `P_kW`, `dt`
+- Cada arquivo representa um percurso diferente
+- Mínimo de 2 percursos por cliente recomendado
+
+## 🚀 Execução em Ambiente Distribuído
+
+### Configuração de Rede
+
+1. **Identifique o IP do servidor Windows:**
+   ```powershell
+   ipconfig
+   ```
+   Procure pelo IPv4 Address (ex: 192.168.1.100)
+
+2. **Teste a conectividade dos clientes Ubuntu:**
+   ```bash
+   ping 192.168.1.100
+   ```
+
+### Passo 1: Iniciar o Servidor (Windows)
+
+```powershell
+# Ative o ambiente virtual
+.\venv\Scripts\activate
+
+# Execute o servidor
+python server.py --strategy fedavg --rounds 15
+
+# Ou com parâmetros customizados
+python server.py --strategy fedadam --rounds 20 --min-clients 3
+```
+
+O servidor iniciará na porta 8080 e aguardará a conexão dos clientes.
+
+### Passo 2: Iniciar os Clientes (Ubuntu)
+
+**Em cada máquina Ubuntu, execute em terminais separados:**
+
+**Cliente 1:**
+```bash
+# Ative o ambiente virtual
+source venv/bin/activate
+
+# Execute o cliente 1
+python client.py --client-id 1 --server-address 192.168.1.100:8080 --prediction-length 10
+```
+
+**Cliente 2:**
+```bash
+source venv/bin/activate
+python client.py --client-id 2 --server-address 192.168.1.100:8080 --prediction-length 10
+```
+
+**Cliente 3:**
+```bash
+source venv/bin/activate
+python client.py --client-id 3 --server-address 192.168.1.100:8080 --prediction-length 10
+```
+
+### Monitoramento
+
+O progresso será exibido em tempo real:
+- **Servidor**: Mostra rodadas completas e métricas globais
+- **Clientes**: Exibem perdas locais de treino/validação
+
+## 📊 Análise dos Resultados
+
+### Após o Treinamento
+
+1. **Executar análise automática:**
+   ```bash
+   python analysis_tool.py --results-dir results
+   ```
+
+2. **Visualizações geradas (PDFs):**
+   - `performance_analysis_*.pdf`: Análise de desempenho completa
+   - `convergence_analysis_*.pdf`: Métricas de convergência
+   - `heatmap_performance_*.pdf`: Mapa de calor temporal
+   - `comparative_analysis.pdf`: Comparação entre estratégias
+   - `client_evolution_analysis.pdf`: Evolução individual
+
+3. **Métricas salvas:**
+   - `results/detailed_metrics_*.csv`: Dados completos
+   - `results/summary_report.json`: Relatório consolidado
+   - `metrics/client_*/metrics_history.json`: Histórico por cliente
+
+## 🔬 Estratégias de Agregação
+
+| Estratégia | Descrição | Quando Usar |
+|------------|-----------|-------------|
+| **FedAvg** | Média ponderada simples | Dados homogêneos |
+| **FedAdam** | Otimização adaptativa | Convergência mais rápida |
+| **FedYogi** | Adam com controle de variância | Dados heterogêneos |
+| **FedAdagrad** | Taxa de aprendizado adaptativa | Dados esparsos |
+
+### Comparar Todas as Estratégias
+
+```bash
+# Linux/Ubuntu
+chmod +x run_all_strategies.sh
+./run_all_strategies.sh 15 10
+
+# Windows (usando Git Bash ou WSL)
+bash run_all_strategies.sh 15 10
+```
+
+## 🛠️ Troubleshooting
+
+### Erro de Conexão
+
+**Problema**: Clientes não conseguem conectar ao servidor
+
+**Soluções**:
+1. Verifique o firewall do Windows:
+   ```powershell
+   # Permitir porta 8080
+   netsh advfirewall firewall add rule name="FL Server" dir=in action=allow protocol=TCP localport=8080
+   ```
+
+2. Confirme que o servidor está rodando:
+   ```powershell
+   netstat -an | findstr :8080
+   ```
+
+### Erro de Memória
+
+**Problema**: Out of Memory durante treinamento
+
+**Soluções**:
+1. Reduza o batch_size em `utils.py`
+2. Diminua sequence_length ou prediction_length
+3. Use menos épocas por rodada
+
+### Dados Insuficientes
+
+**Problema**: "conjunto de treino ou teste vazio"
+
+**Soluções**:
+1. Verifique se há dados suficientes em `data/client_X/`
+2. Ajuste sequence_length e prediction_length
+3. Confirme que os CSVs têm as colunas esperadas
+
+## 📈 Parâmetros Importantes
+
+### Server.py
+- `--strategy`: Estratégia de agregação (fedavg, fedadam, etc.)
+- `--rounds`: Número de rodadas de FL (default: 10)
+- `--min-clients`: Clientes mínimos para iniciar (default: 3)
+
+### Client.py
+- `--client-id`: ID do cliente (1, 2 ou 3)
+- `--server-address`: Endereço IP:porta do servidor
+- `--prediction-length`: Passos futuros a prever (default: 10)
+
+### Utils.py (configurações internas)
+- `sequence_length`: Janela de entrada (default: 60)
+- `batch_size`: Tamanho do batch (default: 32)
+- `learning_rate`: Taxa de aprendizado (default: 1e-5)
+
+## 📝 Notas de Desenvolvimento
+
+### Modelo LSTM
+- Entrada: 6 features (velocidade, RPM, acelerações, consumo, tempo)
+- Hidden size: 50 neurônios
+- Saída: Previsão de N passos futuros de consumo (P_kW)
+
+### Divisão dos Dados
+- 80% para treinamento
+- 20% para validação
+- Normalização MinMaxScaler por cliente
+
+### Métricas
+- Loss: MSE (Mean Squared Error)
+- Avaliação: Por cliente e global
+- Convergência: Variância entre clientes
+
+## 🤝 Contribuindo
+
+1. Fork o projeto
+2. Crie sua feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit suas mudanças (`git commit -m 'Add some AmazingFeature'`)
+4. Push para a branch (`git push origin feature/AmazingFeature`)
+5. Abra um Pull Request
+
+## 📄 Licença
+
+Distribuído sob a licença MIT. Veja `LICENSE` para mais informações.
+
+## 👥 Autores
+
+- José Wilson C. Souza
+- Erick Andrade Borba
+- João Alfredo Cal Braz
+
+## 🙏 Agradecimentos
+
+- [Flower Framework](https://flower.dev/) - Framework de Aprendizado Federado
+- [PyTorch](https://pytorch.org/) - Framework de Deep Learning
+- Dados coletados via OBD Link
+
+---

analysis_tool.py

@@ -0,0 +1,388 @@
+ #!/usr/bin/env python3
+"""
+Ferramenta de análise pós-treinamento para comparar resultados de diferentes estratégias
+e gerar relatórios consolidados.
+"""
+
+import json
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from pathlib import Path
+import argparse
+from typing import Dict, List
+
+plt.style.use('seaborn-v0_8-darkgrid')
+sns.set_palette("husl")
+
+class FLAnalyzer:
+    """Analisador de resultados de Aprendizado Federado."""
+    
+    def __init__(self, results_dir: str = "results"):
+        self.results_dir = Path(results_dir)
+        self.metrics_dir = Path("metrics")
+        self.strategies_data = {}
+        self.client_data = {}
+        
+    def load_server_metrics(self):
+        """Carrega métricas do servidor para todas as estratégias."""
+        print("Carregando métricas do servidor...")
+        
+        for csv_file in self.results_dir.glob("detailed_metrics_*.csv"):
+            strategy = csv_file.stem.replace("detailed_metrics_", "")
+            df = pd.read_csv(csv_file)
+            self.strategies_data[strategy] = df
+            print(f"  - Carregado: {strategy}")
+    
+    def load_client_metrics(self):
+        """Carrega métricas individuais dos clientes."""
+        print("Carregando métricas dos clientes...")
+        
+        for client_dir in self.metrics_dir.glob("client_*"):
+            client_id = int(client_dir.name.split("_")[1])
+            metrics_file = client_dir / "metrics_history.json"
+            
+            if metrics_file.exists():
+                with open(metrics_file, 'r') as f:
+                    self.client_data[client_id] = json.load(f)
+                print(f"  - Cliente {client_id} carregado")
+    
+    def generate_comparative_analysis(self):
+        """Gera análise comparativa entre estratégias."""
+        if not self.strategies_data:
+            print("Nenhum dado de estratégia encontrado!")
+            return
+        
+        fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+        
+        # 1. Comparação de convergência entre estratégias
+        ax1 = axes[0, 0]
+        for strategy, df in self.strategies_data.items():
+            eval_df = df[df['phase'] == 'eval']
+            if not eval_df.empty and 'global_eval_loss' in eval_df.columns:
+                ax1.plot(eval_df['rounds'], eval_df['global_eval_loss'], 
+                        marker='o', label=strategy.upper(), linewidth=2)
+        
+        ax1.set_title('Comparação de Convergência entre Estratégias', fontsize=14, fontweight='bold')
+        ax1.set_xlabel('Rodada')
+        ax1.set_ylabel('Perda de Validação Global')
+        ax1.legend()
+        ax1.grid(True, alpha=0.3)
+        
+        # 2. Taxa de convergência
+        ax2 = axes[0, 1]
+        convergence_rates = {}
+        
+        for strategy, df in self.strategies_data.items():
+            eval_df = df[df['phase'] == 'eval']
+            if not eval_df.empty and 'global_eval_loss' in eval_df.columns:
+                losses = eval_df['global_eval_loss'].values
+                if len(losses) > 1:
+                    # Taxa de melhoria por rodada
+                    improvements = -np.diff(losses)
+                    convergence_rates[strategy] = improvements
+                    ax2.plot(eval_df['rounds'].values[1:], improvements, 
+                            marker='s', label=strategy.upper(), linewidth=1.5, alpha=0.7)
+        
+        ax2.axhline(y=0, color='k', linestyle='--', alpha=0.5)
+        ax2.set_title('Taxa de Melhoria por Rodada', fontsize=14, fontweight='bold')
+        ax2.set_xlabel('Rodada')
+        ax2.set_ylabel('Redução na Perda')
+        ax2.legend()
+        ax2.grid(True, alpha=0.3)
+        
+        # 3. Boxplot de desempenho final dos clientes
+        ax3 = axes[1, 0]
+        final_performances = []
+        labels = []
+        
+        for strategy, df in self.strategies_data.items():
+            eval_df = df[df['phase'] == 'eval']
+            if not eval_df.empty:
+                last_round = eval_df['rounds'].max()
+                last_round_data = eval_df[eval_df['rounds'] == last_round]
+                
+                client_losses = []
+                for i in range(1, 4):
+                    col = f'client_{i}_eval_loss'
+                    if col in last_round_data.columns:
+                        value = last_round_data[col].values
+                        if len(value) > 0 and not pd.isna(value[0]):
+                            client_losses.append(value[0])
+                
+                if client_losses:
+                    final_performances.append(client_losses)
+                    labels.append(strategy.upper())
+        
+        if final_performances:
+            bp = ax3.boxplot(final_performances, labels=labels, patch_artist=True)
+            for patch, color in zip(bp['boxes'], sns.color_palette("husl", len(labels))):
+                patch.set_facecolor(color)
+                patch.set_alpha(0.7)
+            
+            ax3.set_title('Distribuição Final de Desempenho dos Clientes', fontsize=14, fontweight='bold')
+            ax3.set_xlabel('Estratégia')
+            ax3.set_ylabel('Perda Final de Validação')
+            ax3.grid(True, alpha=0.3, axis='y')
+        
+        # 4. Métricas de eficiência
+        ax4 = axes[1, 1]
+        strategies = []
+        metrics_data = {
+            'Convergência': [],
+            'Estabilidade': [],
+            'Heterogeneidade': []
+        }
+        
+        for strategy, df in self.strategies_data.items():
+            eval_df = df[df['phase'] == 'eval']
+            if not eval_df.empty and 'global_eval_loss' in eval_df.columns:
+                strategies.append(strategy.upper())
+                
+                # Convergência: melhoria total
+                losses = eval_df['global_eval_loss'].values
+                if len(losses) > 1:
+                    convergence = (losses[0] - losses[-1]) / losses[0]
+                    metrics_data['Convergência'].append(convergence)
+                else:
+                    metrics_data['Convergência'].append(0)
+                
+                # Estabilidade: desvio padrão das mudanças
+                if len(losses) > 1:
+                    changes = np.diff(losses)
+                    stability = 1 / (1 + np.std(changes))  # Invertido para que maior = mais estável
+                    metrics_data['Estabilidade'].append(stability)
+                else:
+                    metrics_data['Estabilidade'].append(0)
+                
+                # Heterogeneidade: variação média entre clientes
+                client_cols = [f'client_{i}_eval_loss' for i in range(1, 4)]
+                last_round = eval_df['rounds'].max()
+                last_round_data = eval_df[eval_df['rounds'] == last_round]
+                
+                client_values = []
+                for col in client_cols:
+                    if col in last_round_data.columns:
+                        val = last_round_data[col].values
+                        if len(val) > 0 and not pd.isna(val[0]):
+                            client_values.append(val[0])
+                
+                if len(client_values) > 1:
+                    heterogeneity = 1 / (1 + np.std(client_values))  # Invertido
+                    metrics_data['Heterogeneidade'].append(heterogeneity)
+                else:
+                    metrics_data['Heterogeneidade'].append(0)
+        
+        if strategies:
+            x = np.arange(len(strategies))
+            width = 0.25
+            
+            for i, (metric, values) in enumerate(metrics_data.items()):
+                ax4.bar(x + i * width, values, width, label=metric, alpha=0.8)
+            
+            ax4.set_xlabel('Estratégia')
+            ax4.set_ylabel('Score Normalizado')
+            ax4.set_title('Métricas de Eficiência Comparativas', fontsize=14, fontweight='bold')
+            ax4.set_xticks(x + width)
+            ax4.set_xticklabels(strategies)
+            ax4.legend()
+            ax4.grid(True, alpha=0.3, axis='y')
+        
+        plt.suptitle('Análise Comparativa de Estratégias de Aprendizado Federado', 
+                     fontsize=16, fontweight='bold')
+        plt.tight_layout()
+        plt.savefig(self.results_dir / 'comparative_analysis.pdf', dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        print(f"Análise comparativa salva em: {self.results_dir / 'comparative_analysis.pdf'}")
+    
+    def generate_client_evolution_analysis(self):
+        """Analisa a evolução individual dos clientes."""
+        if not self.client_data:
+            print("Nenhum dado de cliente encontrado!")
+            return
+        
+        fig, axes = plt.subplots(2, 2, figsize=(15, 10))
+        
+        # 1. Evolução do treinamento por cliente
+        ax1 = axes[0, 0]
+        for client_id, data in self.client_data.items():
+            if 'rounds' in data and 'train_losses' in data:
+                ax1.plot(data['rounds'], data['train_losses'], 
+                        marker='o', label=f'Cliente {client_id}', linewidth=2)
+        
+        ax1.set_title('Evolução do Treinamento por Cliente', fontsize=14, fontweight='bold')
+        ax1.set_xlabel('Rodada')
+        ax1.set_ylabel('Perda de Treinamento')
+        ax1.legend()
+        ax1.grid(True, alpha=0.3)
+        
+        # 2. Evolução da validação por cliente
+        ax2 = axes[0, 1]
+        for client_id, data in self.client_data.items():
+            if 'eval_losses' in data and data['eval_losses']:
+                rounds = list(range(1, len(data['eval_losses']) + 1))
+                ax2.plot(rounds, data['eval_losses'], 
+                        marker='s', label=f'Cliente {client_id}', linewidth=2)
+        
+        ax2.set_title('Evolução da Validação por Cliente', fontsize=14, fontweight='bold')
+        ax2.set_xlabel('Rodada')
+        ax2.set_ylabel('Perda de Validação')
+        ax2.legend()
+        ax2.grid(True, alpha=0.3)
+        
+        # 3. Mudanças nos parâmetros do modelo
+        ax3 = axes[1, 0]
+        for client_id, data in self.client_data.items():
+            if 'model_updates' in data and data['model_updates']:
+                rounds = list(range(1, len(data['model_updates']) + 1))
+                ax3.plot(rounds, data['model_updates'], 
+                        marker='^', label=f'Cliente {client_id}', linewidth=1.5, alpha=0.7)
+        
+        ax3.set_title('Magnitude das Atualizações do Modelo', fontsize=14, fontweight='bold')
+        ax3.set_xlabel('Rodada')
+        ax3.set_ylabel('Mudança Média nos Parâmetros')
+        ax3.legend()
+        ax3.grid(True, alpha=0.3)
+        
+        # 4. Tempo de convergência relativo
+        ax4 = axes[1, 1]
+        convergence_times = []
+        client_ids = []
+        
+        for client_id, data in self.client_data.items():
+            if 'train_losses' in data and len(data['train_losses']) > 1:
+                losses = np.array(data['train_losses'])
+                # Encontrar quando a perda estabiliza (mudança < 1%)
+                for i in range(1, len(losses)):
+                    if abs(losses[i] - losses[i-1]) / losses[i-1] < 0.01:
+                        convergence_times.append(data['rounds'][i])
+                        client_ids.append(f'Cliente {client_id}')
+                        break
+                else:
+                    convergence_times.append(data['rounds'][-1])
+                    client_ids.append(f'Cliente {client_id}')
+        
+        if convergence_times:
+            colors = sns.color_palette("husl", len(client_ids))
+            bars = ax4.bar(client_ids, convergence_times, color=colors, alpha=0.7)
+            ax4.set_title('Tempo de Convergência por Cliente', fontsize=14, fontweight='bold')
+            ax4.set_xlabel('Cliente')
+            ax4.set_ylabel('Rodada de Convergência')
+            ax4.grid(True, alpha=0.3, axis='y')
+            
+            # Adicionar valores nas barras
+            for bar, value in zip(bars, convergence_times):
+                height = bar.get_height()
+                ax4.text(bar.get_x() + bar.get_width()/2., height,
+                        f'{value}', ha='center', va='bottom')
+        
+        plt.suptitle('Análise de Evolução Individual dos Clientes', 
+                     fontsize=16, fontweight='bold')
+        plt.tight_layout()
+        plt.savefig(self.results_dir / 'client_evolution_analysis.pdf', dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        print(f"Análise de evolução dos clientes salva em: {self.results_dir / 'client_evolution_analysis.pdf'}")
+    
+    def generate_summary_report(self):
+        """Gera relatório resumido em formato texto e JSON."""
+        report = {
+            "timestamp": pd.Timestamp.now().isoformat(),
+            "strategies_analyzed": list(self.strategies_data.keys()),
+            "clients_analyzed": list(self.client_data.keys()),
+            "summary": {}
+        }
+        
+        # Análise por estratégia
+        for strategy, df in self.strategies_data.items():
+            eval_df = df[df['phase'] == 'eval']
+            train_df = df[df['phase'] == 'train']
+            
+            strategy_summary = {
+                "total_rounds": int(eval_df['rounds'].max()) if not eval_df.empty else 0,
+                "final_global_eval_loss": float(eval_df['global_eval_loss'].iloc[-1]) if not eval_df.empty else None,
+                "final_global_train_loss": float(train_df['global_train_loss'].iloc[-1]) if not train_df.empty else None,
+            }
+            
+            # Calcular métricas de melhoria
+            if not eval_df.empty and len(eval_df) > 1:
+                initial = eval_df['global_eval_loss'].iloc[0]
+                final = eval_df['global_eval_loss'].iloc[-1]
+                strategy_summary["improvement_percentage"] = float((initial - final) / initial * 100)
+                strategy_summary["convergence_rate"] = float(np.mean(np.diff(eval_df['global_eval_loss'].values)))
+            
+            # Métricas por cliente
+            client_metrics = {}
+            for i in range(1, 4):
+                col = f'client_{i}_eval_loss'
+                if col in eval_df.columns:
+                    client_losses = eval_df[col].dropna()
+                    if not client_losses.empty:
+                        client_metrics[f'client_{i}'] = {
+                            "final_loss": float(client_losses.iloc[-1]),
+                            "best_loss": float(client_losses.min()),
+                            "worst_loss": float(client_losses.max()),
+                            "std_loss": float(client_losses.std())
+                        }
+            
+            strategy_summary["client_metrics"] = client_metrics
+            report["summary"][strategy] = strategy_summary
+        
+        # Salvar relatório
+        report_file = self.results_dir / "summary_report.json"
+        with open(report_file, 'w') as f:
+            json.dump(report, f, indent=2)
+        
+        print(f"\nRelatório resumido salvo em: {report_file}")
+        
+        # Imprimir resumo no console
+        print("\n" + "="*60)
+        print("RESUMO DA ANÁLISE")
+        print("="*60)
+        
+        for strategy, summary in report["summary"].items():
+            print(f"\nEstratégia: {strategy.upper()}")
+            print(f"  - Rodadas totais: {summary['total_rounds']}")
+            print(f"  - Perda final (validação): {summary['final_global_eval_loss']:.6f}" if summary['final_global_eval_loss'] else "  - Perda final: N/A")
+            print(f"  - Melhoria: {summary.get('improvement_percentage', 0):.2f}%")
+            
+            if summary['client_metrics']:
+                print("  - Desempenho por cliente:")
+                for client, metrics in summary['client_metrics'].items():
+                    print(f"    {client}: Final={metrics['final_loss']:.6f}, Melhor={metrics['best_loss']:.6f}")
+    
+    def run_full_analysis(self):
+        """Executa análise completa."""
+        print("\n" + "="*60)
+        print("INICIANDO ANÁLISE COMPLETA DOS RESULTADOS")
+        print("="*60 + "\n")
+        
+        self.load_server_metrics()
+        self.load_client_metrics()
+        
+        if self.strategies_data:
+            self.generate_comparative_analysis()
+        
+        if self.client_data:
+            self.generate_client_evolution_analysis()
+        
+        if self.strategies_data or self.client_data:
+            self.generate_summary_report()
+        
+        print("\n" + "="*60)
+        print("ANÁLISE COMPLETA FINALIZADA")
+        print("="*60)
+
+def main():
+    parser = argparse.ArgumentParser(description="Análise de Resultados FL")
+    parser.add_argument("--results-dir", type=str, default="results", 
+                       help="Diretório com os resultados")
+    args = parser.parse_args()
+    
+    analyzer = FLAnalyzer(args.results_dir)
+    analyzer.run_full_analysis()
+
+if __name__ == "__main__":
+    main()

client.py

@@ -0,0 +1,197 @@
+import argparse
+import flwr as fl
+import torch
+import json
+import numpy as np
+from collections import OrderedDict
+from pathlib import Path
+from datetime import datetime
+
+from utils import Net, load_data, train, test
+
+# Argumentos da linha de comando para identificar o cliente
+parser = argparse.ArgumentParser(description="Flower Client")
+parser.add_argument("--client-id", type=int, required=True, help="ID do Cliente (1, 2, ou 3)")
+parser.add_argument("--server-address", type=str, default="127.0.0.1:8080", help="Endereço do servidor")
+parser.add_argument(
+    "--prediction-length",
+    type=int,
+    default=10,
+    help="Define quantos passos no futuro o modelo deve prever."
+)
+
+# Checa 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):
+        self.client_id = client_id
+        self.metrics = {
+            "client_id": client_id,
+            "rounds": [],
+            "train_losses": [],
+            "eval_losses": [],
+            "timestamps": [],
+            "model_updates": []
+        }
+        self.output_dir = Path(f"metrics/client_{client_id}")
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+    
+    def add_train_metrics(self, round_num, loss):
+        """Adiciona métricas de treinamento."""
+        self.metrics["rounds"].append(round_num)
+        self.metrics["train_losses"].append(float(loss))
+        self.metrics["timestamps"].append(datetime.now().isoformat())
+    
+    def add_eval_metrics(self, loss):
+        """Adiciona métricas de avaliação."""
+        self.metrics["eval_losses"].append(float(loss))
+    
+    def add_model_update(self, params_diff):
+        """Rastreia mudanças nos parâmetros do modelo."""
+        self.metrics["model_updates"].append(float(params_diff))
+    
+    def save_metrics(self):
+        """Salva as métricas em arquivo JSON."""
+        output_file = self.output_dir / f"metrics_history.json"
+        with open(output_file, 'w') as f:
+            json.dump(self.metrics, f, indent=2)
+        print(f"[Cliente {self.client_id}] Métricas salvas em {output_file}")
+    
+    def save_checkpoint(self, model, round_num):
+        """Salva checkpoint do modelo."""
+        checkpoint_file = self.output_dir / f"model_round_{round_num}.pt"
+        torch.save(model.state_dict(), checkpoint_file)
+        print(f"[Cliente {self.client_id}] Checkpoint salvo: {checkpoint_file}")
+
+def calculate_params_diff(old_params, new_params):
+    """Calcula a diferença entre parâmetros antigos e novos."""
+    if old_params is None:
+        return 0.0
+    
+    total_diff = 0.0
+    for old, new in zip(old_params, new_params):
+        diff = np.mean(np.abs(old - new))
+        total_diff += diff
+    
+    return total_diff / len(old_params)
+
+def main():
+    args = parser.parse_args()
+    
+    # Carrega dados específicos deste cliente
+    print(f"Carregando dados para o cliente {args.client_id}...")
+    print(f"Dispositivo: {DEVICE}")
+    
+    trainloader, testloader, num_features = load_data(
+        client_id=args.client_id,
+        prediction_length=args.prediction_length
+    )
+    
+    print(f"Dados carregados: {len(trainloader)} batches de treino, {len(testloader)} batches de teste")
+    
+    # Instancia o modelo
+    print(f"Criando modelo LSTM para prever {args.prediction_length} passos.")
+    net = Net(
+        input_size=num_features,
+        hidden_size=50,
+        output_size=args.prediction_length
+    ).to(DEVICE)
+    
+    # Inicializa o rastreador de métricas
+    metrics_tracker = MetricsTracker(args.client_id)
+    
+    # Implementação do cliente Flower
+    class FlClient(fl.client.NumPyClient):
+        def __init__(self):
+            self.round_num = 0
+            self.previous_params = None
+        
+        def get_parameters(self, config):
+            """Retorna os pesos do modelo local."""
+            return [val.cpu().numpy() for _, val in net.state_dict().items()]
+
+        def set_parameters(self, parameters):
+            """Atualiza os pesos do modelo local com os do servidor."""
+            params_dict = zip(net.state_dict().keys(), parameters)
+            state_dict = OrderedDict({k: torch.tensor(v) for k, v in params_dict})
+            net.load_state_dict(state_dict, strict=True)
+            
+            # Calcula a diferença entre parâmetros
+            if self.previous_params is not None:
+                params_diff = calculate_params_diff(self.previous_params, parameters)
+                metrics_tracker.add_model_update(params_diff)
+            
+            self.previous_params = [p.copy() for p in parameters]
+
+        def fit(self, parameters, config):
+            """Treina o modelo localmente e retorna a perda de treinamento."""
+            self.round_num += 1
+            print(f"\n[Cliente {args.client_id}] === Rodada {self.round_num} ===")
+            
+            # Define os parâmetros recebidos do servidor
+            self.set_parameters(parameters)
+            
+            # Treina o modelo
+            print(f"[Cliente {args.client_id}] Iniciando treinamento...")
+            avg_train_loss = train(net, trainloader, epochs=1, device=DEVICE)
+            
+            # Registra métricas
+            metrics_tracker.add_train_metrics(self.round_num, avg_train_loss)
+            print(f"[Cliente {args.client_id}] Perda de treinamento local: {avg_train_loss:.6f}")
+            
+            # Salva checkpoint a cada 5 rodadas
+            if self.round_num % 5 == 0:
+                metrics_tracker.save_checkpoint(net, self.round_num)
+            
+            # Salva métricas
+            metrics_tracker.save_metrics()
+            
+            return self.get_parameters(config={}), len(trainloader.dataset), {
+                "train_loss": avg_train_loss,
+                "client_id": args.client_id,
+                "round": self.round_num
+            }
+
+        def evaluate(self, parameters, config):
+            """Avalia o modelo localmente."""
+            self.set_parameters(parameters)
+            print(f"[Cliente {args.client_id}] Avaliando modelo...")
+            
+            loss, num_examples = test(net, testloader, device=DEVICE)
+            
+            # Registra métricas de avaliação
+            metrics_tracker.add_eval_metrics(loss)
+            metrics_tracker.save_metrics()
+            
+            print(f"[Cliente {args.client_id}] Perda de validação: {loss:.6f}")
+            
+            return loss, num_examples, {
+                "loss": loss, 
+                "client_id": args.client_id,
+                "round": self.round_num
+            }
+
+    # Inicia o cliente
+    print(f"\n{'='*50}")
+    print(f"Iniciando cliente {args.client_id}")
+    print(f"Conectando ao servidor em {args.server_address}")
+    print(f"Modelo: LSTM com {sum(p.numel() for p in net.parameters())} parâmetros")
+    print(f"{'='*50}\n")
+    
+    try:
+        fl.client.start_client(
+            server_address=args.server_address,
+            client=FlClient().to_client(),
+        )
+
+    except Exception as e:
+        print(f"[Cliente {args.client_id}] Erro: {e}")
+        metrics_tracker.save_metrics()
+    finally:
+        print(f"\n[Cliente {args.client_id}] Finalizado. Métricas salvas em {metrics_tracker.output_dir}")
+
+if __name__ == "__main__":
+    main()

client_1_fedadagrad.log

@@ -0,0 +1,172 @@
+WARNING :   DEPRECATED FEATURE: flwr.client.start_client() is deprecated.
+	Instead, use the `flower-supernode` CLI command to start a SuperNode as shown below:
+
+		$ flower-supernode --insecure --superlink='<IP>:<PORT>'
+
+	To view all available options, run:
+
+		$ flower-supernode --help
+
+	Using `start_client()` is deprecated.
+
+            This is a deprecated feature. It will be removed
+            entirely in future versions of Flower.
+        
+INFO :      
+INFO :      Received: train message 291d80fe-1d64-4e2a-9cc3-c07e0b31623a
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message c9e6f2aa-e700-4c85-a0e9-4e5367b01b52
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 8d273cce-32d4-483d-9588-a016cc012493
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message aba72052-b296-4f4c-99a0-21ab26af46e3
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 65d5ecd1-e554-402a-9c56-935e9c962829
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 65a7d7f4-be1b-4f76-ae2e-d49e50a58219
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 28acbc3d-ed5c-496a-b85e-aa1150fd9de2
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 75b4e73b-f09d-4033-a3fa-43f6f5ed702a
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message f5b93afe-d985-4193-acfb-ab4536c928a4
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 44d83f54-1cdf-4a6e-a9f0-b55b29a55d3b
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 8b6164bb-4371-46fd-8bd6-205790be539a
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message d547915d-42a7-4ce5-a6ca-54d59e933b69
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 0a210acf-de6a-4813-b415-db9d71378c74
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message f321a6c0-ae43-4f82-92b6-00b0955ce4a8
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message a31760dc-1a27-4af3-8f4b-9e849a01d5f7
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 8dea38f0-76a7-4a33-acfb-4a1286102bc1
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 48cfe5e0-b781-4130-8162-c418261ae5a6
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 34a6bbdf-6692-43b6-860f-ac2e416755ea
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 80e5e17b-175c-42e0-be18-bd18436eef6c
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message c2151701-7139-4dd7-b2b1-802805c4da83
+INFO :      Sent reply
+INFO :      
+INFO :      Received: reconnect message f4c73386-bf01-439d-8dca-e7522f1cf998
+INFO :      Disconnect and shut down
+Carregando dados para o cliente 1...
+Dispositivo: cpu
+Dados carregados: 623 batches de treino, 153 batches de teste
+Criando modelo LSTM para prever 90 passos.
+
+==================================================
+Iniciando cliente 1
+Conectando ao servidor em 127.0.0.1:8080
+Modelo: LSTM com 16190 par�metros
+==================================================
+
+
+[Cliente 1] === Rodada 1 ===
+[Cliente 1] Iniciando treinamento...
+[Cliente 1] Perda de treinamento local: 0.011821
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Avaliando modelo...
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Perda de valida��o: 9.976543
+
+[Cliente 1] === Rodada 2 ===
+[Cliente 1] Iniciando treinamento...
+[Cliente 1] Perda de treinamento local: 9.190875
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Avaliando modelo...
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Perda de valida��o: 1.286495
+
+[Cliente 1] === Rodada 3 ===
+[Cliente 1] Iniciando treinamento...
+[Cliente 1] Perda de treinamento local: 0.605915
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Avaliando modelo...
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Perda de valida��o: 0.279315
+
+[Cliente 1] === Rodada 4 ===
+[Cliente 1] Iniciando treinamento...
+[Cliente 1] Perda de treinamento local: 0.197050
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Avaliando modelo...
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Perda de valida��o: 0.596508
+
+[Cliente 1] === Rodada 5 ===
+[Cliente 1] Iniciando treinamento...
+[Cliente 1] Perda de treinamento local: 0.139895
+[Cliente 1] Checkpoint salvo: metrics\client_1\model_round_5.pt
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Avaliando modelo...
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Perda de valida��o: 0.038253
+
+[Cliente 1] === Rodada 6 ===
+[Cliente 1] Iniciando treinamento...
+[Cliente 1] Perda de treinamento local: 0.020903
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Avaliando modelo...
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Perda de valida��o: 0.267797
+
+[Cliente 1] === Rodada 7 ===
+[Cliente 1] Iniciando treinamento...
+[Cliente 1] Perda de treinamento local: 0.147180
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Avaliando modelo...
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Perda de valida��o: 0.058362
+
+[Cliente 1] === Rodada 8 ===
+[Cliente 1] Iniciando treinamento...
+[Cliente 1] Perda de treinamento local: 0.036225
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Avaliando modelo...
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Perda de valida��o: 0.081573
+
+[Cliente 1] === Rodada 9 ===
+[Cliente 1] Iniciando treinamento...
+[Cliente 1] Perda de treinamento local: 0.021779
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Avaliando modelo...
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Perda de valida��o: 0.029207
+
+[Cliente 1] === Rodada 10 ===
+[Cliente 1] Iniciando treinamento...
+[Cliente 1] Perda de treinamento local: 0.014076
+[Cliente 1] Checkpoint salvo: metrics\client_1\model_round_10.pt
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Avaliando modelo...
+[Cliente 1] M�tricas salvas em metrics\client_1\metrics_history.json
+[Cliente 1] Perda de valida��o: 0.024229
+
+[Cliente 1] Finalizado. M�tricas salvas em metrics\client_1

client_2_fedadagrad.log

@@ -0,0 +1,172 @@
+WARNING :   DEPRECATED FEATURE: flwr.client.start_client() is deprecated.
+	Instead, use the `flower-supernode` CLI command to start a SuperNode as shown below:
+
+		$ flower-supernode --insecure --superlink='<IP>:<PORT>'
+
+	To view all available options, run:
+
+		$ flower-supernode --help
+
+	Using `start_client()` is deprecated.
+
+            This is a deprecated feature. It will be removed
+            entirely in future versions of Flower.
+        
+INFO :      
+INFO :      Received: train message f63b3be7-35a8-40b1-a0a9-20bce59fac6e
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 9f3010c9-fa04-4d9e-8803-979b37827a84
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 0c6e2356-9efe-4475-b69a-c6588ef3b826
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 32f6c96c-e75e-484f-9e91-a86cf19961da
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 6d672c95-660d-4d9a-9d46-5b68d91c375a
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 395215b3-06dc-411a-a836-fd88fe798d47
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 9d3c92a9-6163-40d9-914c-555d23d5e4d0
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 235e95a8-6a3b-4d55-a3ff-952b9db35949
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 5accefb0-48ed-40aa-a7bb-16c5c02ef94f
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 3c57952d-2100-4363-a3ec-eab5f84023bf
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 20d1f6d1-07fb-4130-8567-1fbaa05e5740
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 8438ac71-a3ca-4651-ace0-eedd0d24ff66
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 8756ce44-0d73-4d3c-9929-54b9c30f0497
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message d9094dbc-7205-43e9-bb8d-b90a3acf2ed5
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 306a0600-bd21-42c9-9ce3-e907fb67ad37
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message d80fe3a9-259a-4bb5-bd25-3c7b42f93669
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 8b553028-68ab-44a9-836e-74e9325db492
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message d9cc9852-c707-47f0-ac29-443948f7081d
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message f3758c26-02ea-4f19-9f0f-765b2e0e805e
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message c0d18b3e-93f7-4262-88e9-a2390bf4c14f
+INFO :      Sent reply
+INFO :      
+INFO :      Received: reconnect message f2598685-f192-43a1-a234-4382f8ed8e70
+INFO :      Disconnect and shut down
+Carregando dados para o cliente 2...
+Dispositivo: cpu
+Dados carregados: 790 batches de treino, 194 batches de teste
+Criando modelo LSTM para prever 90 passos.
+
+==================================================
+Iniciando cliente 2
+Conectando ao servidor em 127.0.0.1:8080
+Modelo: LSTM com 16190 par�metros
+==================================================
+
+
+[Cliente 2] === Rodada 1 ===
+[Cliente 2] Iniciando treinamento...
+[Cliente 2] Perda de treinamento local: 0.005995
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Avaliando modelo...
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Perda de valida��o: 10.002637
+
+[Cliente 2] === Rodada 2 ===
+[Cliente 2] Iniciando treinamento...
+[Cliente 2] Perda de treinamento local: 9.031767
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Avaliando modelo...
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Perda de valida��o: 1.361941
+
+[Cliente 2] === Rodada 3 ===
+[Cliente 2] Iniciando treinamento...
+[Cliente 2] Perda de treinamento local: 0.753927
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Avaliando modelo...
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Perda de valida��o: 0.240407
+
+[Cliente 2] === Rodada 4 ===
+[Cliente 2] Iniciando treinamento...
+[Cliente 2] Perda de treinamento local: 0.163903
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Avaliando modelo...
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Perda de valida��o: 0.388674
+
+[Cliente 2] === Rodada 5 ===
+[Cliente 2] Iniciando treinamento...
+[Cliente 2] Perda de treinamento local: 0.204387
+[Cliente 2] Checkpoint salvo: metrics\client_2\model_round_5.pt
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Avaliando modelo...
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Perda de valida��o: 0.032693
+
+[Cliente 2] === Rodada 6 ===
+[Cliente 2] Iniciando treinamento...
+[Cliente 2] Perda de treinamento local: 0.016730
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Avaliando modelo...
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Perda de valida��o: 0.273893
+
+[Cliente 2] === Rodada 7 ===
+[Cliente 2] Iniciando treinamento...
+[Cliente 2] Perda de treinamento local: 0.125370
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Avaliando modelo...
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Perda de valida��o: 0.060165
+
+[Cliente 2] === Rodada 8 ===
+[Cliente 2] Iniciando treinamento...
+[Cliente 2] Perda de treinamento local: 0.032033
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Avaliando modelo...
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Perda de valida��o: 0.072853
+
+[Cliente 2] === Rodada 9 ===
+[Cliente 2] Iniciando treinamento...
+[Cliente 2] Perda de treinamento local: 0.017977
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Avaliando modelo...
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Perda de valida��o: 0.029051
+
+[Cliente 2] === Rodada 10 ===
+[Cliente 2] Iniciando treinamento...
+[Cliente 2] Perda de treinamento local: 0.014848
+[Cliente 2] Checkpoint salvo: metrics\client_2\model_round_10.pt
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Avaliando modelo...
+[Cliente 2] M�tricas salvas em metrics\client_2\metrics_history.json
+[Cliente 2] Perda de valida��o: 0.017167
+
+[Cliente 2] Finalizado. M�tricas salvas em metrics\client_2

client_3_fedadagrad.log

@@ -0,0 +1,172 @@
+WARNING :   DEPRECATED FEATURE: flwr.client.start_client() is deprecated.
+	Instead, use the `flower-supernode` CLI command to start a SuperNode as shown below:
+
+		$ flower-supernode --insecure --superlink='<IP>:<PORT>'
+
+	To view all available options, run:
+
+		$ flower-supernode --help
+
+	Using `start_client()` is deprecated.
+
+            This is a deprecated feature. It will be removed
+            entirely in future versions of Flower.
+        
+INFO :      
+INFO :      Received: train message 5bf40068-c93c-4602-bf14-895c53f8261d
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message e60b7d20-e6fb-4b54-bba5-54996ce4715b
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 7f1c0945-8a25-4062-9b42-482284436d2f
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 2ae803e1-04a1-4dde-b2a9-74af9730b699
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 6001a64d-9f07-4e76-a36e-ef21f12f0603
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 2f886dc7-3aaa-457f-bbcd-a31e13a35538
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 109d8ec5-7e2a-4451-acb4-1b455598091d
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 146896ae-66fb-4dcf-ae0e-b671f39730c7
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message d93e8bde-83f5-4213-aa66-31a52f8670dc
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message c96107d0-5866-46de-b168-dd8d6370e53c
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message e1bb6d68-e284-4a31-991f-4fdeb7727b6a
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 084dbcf4-ee02-460c-a8e4-a0117faef750
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 98c62b99-2c4e-4b91-8d65-d62b483eeafb
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message a5c80502-28c4-46ce-bcf2-615d0940bd83
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 4eade5d9-3553-4fcc-bc8f-87abe591fa5b
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 40d2c213-cb1d-42fe-b73a-8ca2de4763b6
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 729add19-adf9-40d2-961a-574782e0637b
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 153d4189-00f1-4f9e-86c1-f4fb126fe539
+INFO :      Sent reply
+INFO :      
+INFO :      Received: train message 72102c53-639a-4983-b85a-57b20d5a52b3
+INFO :      Sent reply
+INFO :      
+INFO :      Received: evaluate message 24104043-0419-439f-9bba-3da769cb80ef
+INFO :      Sent reply
+INFO :      
+INFO :      Received: reconnect message 8f83b63e-303b-4178-b218-4eb319429999
+INFO :      Disconnect and shut down
+Carregando dados para o cliente 3...
+Dispositivo: cpu
+Dados carregados: 992 batches de treino, 245 batches de teste
+Criando modelo LSTM para prever 90 passos.
+
+==================================================
+Iniciando cliente 3
+Conectando ao servidor em 127.0.0.1:8080
+Modelo: LSTM com 16190 par�metros
+==================================================
+
+
+[Cliente 3] === Rodada 1 ===
+[Cliente 3] Iniciando treinamento...
+[Cliente 3] Perda de treinamento local: 0.047731
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Avaliando modelo...
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Perda de valida��o: 9.831532
+
+[Cliente 3] === Rodada 2 ===
+[Cliente 3] Iniciando treinamento...
+[Cliente 3] Perda de treinamento local: 8.576512
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Avaliando modelo...
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Perda de valida��o: 1.461328
+
+[Cliente 3] === Rodada 3 ===
+[Cliente 3] Iniciando treinamento...
+[Cliente 3] Perda de treinamento local: 0.702148
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Avaliando modelo...
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Perda de valida��o: 0.341640
+
+[Cliente 3] === Rodada 4 ===
+[Cliente 3] Iniciando treinamento...
+[Cliente 3] Perda de treinamento local: 0.209710
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Avaliando modelo...
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Perda de valida��o: 0.511448
+
+[Cliente 3] === Rodada 5 ===
+[Cliente 3] Iniciando treinamento...
+[Cliente 3] Perda de treinamento local: 0.252078
+[Cliente 3] Checkpoint salvo: metrics\client_3\model_round_5.pt
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Avaliando modelo...
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Perda de valida��o: 0.058146
+
+[Cliente 3] === Rodada 6 ===
+[Cliente 3] Iniciando treinamento...
+[Cliente 3] Perda de treinamento local: 0.039224
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Avaliando modelo...
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Perda de valida��o: 0.304315
+
+[Cliente 3] === Rodada 7 ===
+[Cliente 3] Iniciando treinamento...
+[Cliente 3] Perda de treinamento local: 0.190494
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Avaliando modelo...
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Perda de valida��o: 0.058137
+
+[Cliente 3] === Rodada 8 ===
+[Cliente 3] Iniciando treinamento...
+[Cliente 3] Perda de treinamento local: 0.039078
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Avaliando modelo...
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Perda de valida��o: 0.083307
+
+[Cliente 3] === Rodada 9 ===
+[Cliente 3] Iniciando treinamento...
+[Cliente 3] Perda de treinamento local: 0.034105
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Avaliando modelo...
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Perda de valida��o: 0.049672
+
+[Cliente 3] === Rodada 10 ===
+[Cliente 3] Iniciando treinamento...
+[Cliente 3] Perda de treinamento local: 0.031320
+[Cliente 3] Checkpoint salvo: metrics\client_3\model_round_10.pt
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Avaliando modelo...
+[Cliente 3] M�tricas salvas em metrics\client_3\metrics_history.json
+[Cliente 3] Perda de valida��o: 0.029677
+
+[Cliente 3] Finalizado. M�tricas salvas em metrics\client_3

requeriments.txt

@@ -0,0 +1,33 @@
+# Core FL Framework
+flwr==1.10.0
+flwr-datasets==0.3.0
+
+# Deep Learning
+torch==2.0.1
+torchvision==0.15.2
+torchaudio==2.0.2
+
+# Data Processing & Analysis
+numpy==1.24.3
+pandas==2.0.3
+scikit-learn==1.3.0
+scipy==1.11.1
+
+# Visualization
+matplotlib==3.7.2
+seaborn==0.12.2
+
+# Network & System
+psutil==5.9.5
+requests==2.31.0
+
+# Development Tools (optional but recommended)
+jupyter==1.0.0
+ipython==8.14.0
+tqdm==4.65.0
+
+# For Windows compatibility
+pywin32==306; sys_platform == 'win32'
+
+# For Linux compatibility
+python-dotenv==1.0.0

run.sh

@@ -0,0 +1,227 @@
+#!/bin/bash
+
+# Cores para output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Configurações
+STRATEGY=${1:-fedavg}  # Estratégia padrão: fedavg
+ROUNDS=${2:-15}         # Número de rodadas padrão: 15
+PREDICTION_LENGTH=${3:-10}  # Tamanho da previsão padrão: 10
+
+echo -e "${BLUE}================================================${NC}"
+echo -e "${BLUE}    SIMULAÇÃO DE APRENDIZADO FEDERADO${NC}"
+echo -e "${BLUE}================================================${NC}"
+echo -e "${GREEN}Estratégia: ${YELLOW}$STRATEGY${NC}"
+echo -e "${GREEN}Rodadas: ${YELLOW}$ROUNDS${NC}"
+echo -e "${GREEN}Tamanho da Previsão: ${YELLOW}$PREDICTION_LENGTH passos${NC}"
+echo -e "${BLUE}================================================${NC}\n"
+
+# Limpar logs anteriores
+echo -e "${YELLOW}Limpando logs anteriores...${NC}"
+rm -f *.log
+rm -rf metrics/
+mkdir -p metrics
+mkdir -p results
+
+# Verificar se os dados existem
+if [ ! -d "data" ]; then
+    echo -e "${RED}Erro: Diretório 'data' não encontrado!${NC}"
+    echo -e "${YELLOW}Certifique-se de que os dados estão organizados em:${NC}"
+    echo "  data/client_1/*.csv"
+    echo "  data/client_2/*.csv"
+    echo "  data/client_3/*.csv"
+    exit 1
+fi
+
+# Função para verificar se o servidor está pronto
+wait_for_server() {
+    echo -e "${YELLOW}Aguardando servidor iniciar...${NC}"
+    for i in {1..30}; do
+        if netstat -an | grep ":8080" | grep -q "LISTENING"; then
+            echo -e "${GREEN}Servidor pronto!${NC}"
+            return 0
+        fi
+        sleep 1
+        echo -n "."
+    done
+    echo -e "\n${RED}Timeout esperando servidor!${NC}"
+    return 1
+}
+
+# Iniciar servidor
+echo -e "${BLUE}Iniciando servidor FL...${NC}"
+#python server.py --strategy $STRATEGY --rounds $ROUNDS > server_$STRATEGY.log 2>&1 &
+python server.py --strategy $STRATEGY --rounds $ROUNDS --prediction-length $PREDICTION_LENGTH > server_$STRATEGY.log 2>&1 &
+SERVER_PID=$!
+
+# Aguardar servidor
+if ! wait_for_server; then
+    echo -e "${RED}Falha ao iniciar servidor. Verifique server_$STRATEGY.log${NC}"
+    exit 1
+fi
+
+# Iniciar clientes
+echo -e "\n${BLUE}Iniciando 3 clientes FL...${NC}"
+CLIENT_PIDS=()
+
+for i in {1..3}; do
+    echo -e "${GREEN}  → Iniciando cliente $i${NC}"
+    python client.py \
+        --client-id $i \
+        --prediction-length $PREDICTION_LENGTH \
+        > client_${i}_$STRATEGY.log 2>&1 &
+    CLIENT_PIDS+=($!)
+    sleep 2  # Pequeno delay entre clientes
+done
+
+# Monitorar progresso
+echo -e "\n${BLUE}================================================${NC}"
+echo -e "${BLUE}    TREINAMENTO EM PROGRESSO${NC}"
+echo -e "${BLUE}================================================${NC}"
+echo -e "${YELLOW}Monitorando treinamento...${NC}"
+echo -e "${YELLOW}Logs disponíveis em:${NC}"
+echo -e "  • Servidor: server_$STRATEGY.log"
+echo -e "  • Clientes: client_*_$STRATEGY.log"
+echo -e "  • Métricas: metrics/client_*/metrics_history.json"
+
+# Função para mostrar progresso
+show_progress() {
+    while kill -0 $SERVER_PID 2>/dev/null; do
+        if [ -f "server_$STRATEGY.log" ]; then
+            CURRENT_ROUND=$(grep -o "round [0-9]*:" server_$STRATEGY.log | tail -1 | grep -o "[0-9]*" || echo "0")
+            if [ ! -z "$CURRENT_ROUND" ] && [ "$CURRENT_ROUND" != "0" ]; then
+                echo -ne "\r${GREEN}Progresso: Rodada $CURRENT_ROUND de $ROUNDS${NC}    "
+            fi
+        fi
+        sleep 2
+    done
+}
+
+# Mostrar progresso
+show_progress
+
+# Aguardar conclusão
+echo -e "\n\n${YELLOW}Aguardando conclusão do treinamento...${NC}"
+wait $SERVER_PID
+SERVER_EXIT_CODE=$?
+
+# Verificar se o servidor terminou com sucesso
+if [ $SERVER_EXIT_CODE -eq 0 ]; then
+    echo -e "${GREEN}✓ Servidor concluído com sucesso!${NC}"
+else
+    echo -e "${RED}✗ Servidor terminou com erro (código: $SERVER_EXIT_CODE)${NC}"
+fi
+
+# Aguardar clientes (com timeout)
+echo -e "${YELLOW}Aguardando clientes finalizarem...${NC}"
+TIMEOUT=30
+for pid in ${CLIENT_PIDS[@]}; do
+    COUNT=0
+    while kill -0 $pid 2>/dev/null && [ $COUNT -lt $TIMEOUT ]; do
+        sleep 1
+        COUNT=$((COUNT + 1))
+    done
+    if [ $COUNT -ge $TIMEOUT ]; then
+        echo -e "${YELLOW}  Cliente PID $pid demorou muito. Finalizando...${NC}"
+        kill $pid 2>/dev/null
+    fi
+done
+
+# Limpar processos órfãos
+echo -e "${YELLOW}Limpando processos...${NC}"
+pkill -f "python client.py" 2>/dev/null
+pkill -f "python server.py" 2>/dev/null
+
+# Executar análise
+echo -e "\n${BLUE}================================================${NC}"
+echo -e "${BLUE}    EXECUTANDO ANÁLISE DOS RESULTADOS${NC}"
+echo -e "${BLUE}================================================${NC}"
+
+if [ -f "analysis_tool.py" ]; then
+    echo -e "${GREEN}Gerando visualizações e relatórios...${NC}"
+    python analysis_tool.py --results-dir results
+    
+    if [ $? -eq 0 ]; then
+        echo -e "${GREEN}✓ Análise concluída com sucesso!${NC}"
+    else
+        echo -e "${RED}✗ Erro na análise dos resultados${NC}"
+    fi
+else
+    echo -e "${YELLOW}Arquivo analysis_tool.py não encontrado. Pulando análise.${NC}"
+fi
+
+# Resumo final
+echo -e "\n${BLUE}================================================${NC}"
+echo -e "${BLUE}    SIMULAÇÃO CONCLUÍDA${NC}"
+echo -e "${BLUE}================================================${NC}"
+
+# Verificar arquivos gerados
+echo -e "${GREEN}Arquivos gerados:${NC}"
+
+# Resultados
+if [ -d "results" ]; then
+    echo -e "\n${YELLOW}Resultados em 'results/':${NC}"
+    ls -la results/*.pdf 2>/dev/null | awk '{print "  • " $9}'
+    ls -la results/*.csv 2>/dev/null | awk '{print "  • " $9}'
+    ls -la results/*.json 2>/dev/null | awk '{print "  • " $9}'
+fi
+
+# Métricas dos clientes
+if [ -d "metrics" ]; then
+    echo -e "\n${YELLOW}Métricas dos clientes em 'metrics/':${NC}"
+    for i in {1..3}; do
+        if [ -f "metrics/client_$i/metrics_history.json" ]; then
+            echo -e "  • Cliente $i: metrics/client_$i/metrics_history.json"
+        fi
+    done
+fi
+
+# Logs
+echo -e "\n${YELLOW}Logs de execução:${NC}"
+ls -la *.log | awk '{print "  • " $9 " (" $5 " bytes)"}'
+
+# Estatísticas finais dos logs
+echo -e "\n${BLUE}Estatísticas Finais:${NC}"
+
+# Extrair perda final do servidor
+if [ -f "server_$STRATEGY.log" ]; then
+    FINAL_LOSS=$(grep "Perda final de treino:" server_$STRATEGY.log | tail -1 | grep -o "[0-9.]*" | head -1)
+    if [ ! -z "$FINAL_LOSS" ]; then
+        echo -e "  ${GREEN}• Perda final de treino (global): $FINAL_LOSS${NC}"
+    fi
+    
+    FINAL_EVAL=$(grep "Perda final de validação:" server_$STRATEGY.log | tail -1 | grep -o "[0-9.]*" | head -1)
+    if [ ! -z "$FINAL_EVAL" ]; then
+        echo -e "  ${GREEN}• Perda final de validação (global): $FINAL_EVAL${NC}"
+    fi
+fi
+
+# Extrair perdas finais dos clientes
+for i in {1..3}; do
+    if [ -f "client_${i}_$STRATEGY.log" ]; then
+        CLIENT_LOSS=$(grep "Perda de validação:" client_${i}_$STRATEGY.log | tail -1 | grep -o "[0-9.]*" | head -1)
+        if [ ! -z "$CLIENT_LOSS" ]; then
+            echo -e "  ${GREEN}• Cliente $i - Perda final: $CLIENT_LOSS${NC}"
+        fi
+    fi
+done
+
+echo -e "\n${BLUE}================================================${NC}"
+echo -e "${GREEN}✓ Simulação completa!${NC}"
+echo -e "${BLUE}================================================${NC}"
+
+# Sugestões
+echo -e "\n${YELLOW}Próximos passos sugeridos:${NC}"
+echo -e "  1. Visualizar os gráficos em ${GREEN}results/*.pdf${NC}"
+echo -e "  2. Analisar métricas detalhadas em ${GREEN}results/detailed_metrics_$STRATEGY.csv${NC}"
+echo -e "  3. Revisar o relatório resumido em ${GREEN}results/summary_report.json${NC}"
+echo -e "  4. Comparar com outras estratégias executando:"
+echo -e "     ${BLUE}./run_enhanced.sh fedadam $ROUNDS${NC}"
+echo -e "     ${BLUE}./run_enhanced.sh fedyogi $ROUNDS${NC}"
+echo -e "     ${BLUE}./run_enhanced.sh fedadagrad $ROUNDS${NC}"
+
+exit $SERVER_EXIT_CODE

run_all_strategies.sh

@@ -0,0 +1,213 @@
+#!/bin/bash
+
+# Script para executar todas as estratégias e gerar comparação final
+
+# Cores para output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+PURPLE='\033[0;35m'
+NC='\033[0m' # No Color
+
+# Configurações
+ROUNDS=${1:-15}
+PREDICTION_LENGTH=${2:-10}
+STRATEGIES=("fedavg" "fedadam" "fedyogi" "fedadagrad")
+
+echo -e "${PURPLE}╔══════════════════════════════════════════════════════╗${NC}"
+echo -e "${PURPLE}║     EXECUÇÃO COMPLETA - TODAS AS ESTRATÉGIAS FL     ║${NC}"
+echo -e "${PURPLE}╚══════════════════════════════════════════════════════╝${NC}"
+echo -e "${GREEN}Rodadas: ${YELLOW}$ROUNDS${NC}"
+echo -e "${GREEN}Tamanho da Previsão: ${YELLOW}$PREDICTION_LENGTH passos${NC}"
+echo -e "${GREEN}Estratégias: ${YELLOW}${STRATEGIES[@]}${NC}"
+echo -e "${PURPLE}════════════════════════════════════════════════════════${NC}\n"
+
+# Criar diretório para resultados consolidados
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+RESULTS_DIR="results_comparison_$TIMESTAMP"
+mkdir -p $RESULTS_DIR
+
+# Log geral
+MAIN_LOG="$RESULTS_DIR/execution_log.txt"
+echo "Execução iniciada em: $(date)" > $MAIN_LOG
+
+# Executar cada estratégia
+for STRATEGY in "${STRATEGIES[@]}"; do
+    echo -e "\n${BLUE}════════════════════════════════════════════════════════${NC}"
+    echo -e "${BLUE}  Executando estratégia: ${YELLOW}$STRATEGY${NC}"
+    echo -e "${BLUE}════════════════════════════════════════════════════════${NC}"
+    
+    # Registrar no log
+    echo -e "\n\n=== ESTRATÉGIA: $STRATEGY ===" >> $MAIN_LOG
+    echo "Início: $(date)" >> $MAIN_LOG
+    
+    # Executar estratégia
+    ./run.sh $STRATEGY $ROUNDS $PREDICTION_LENGTH
+    
+    # Verificar sucesso
+    if [ $? -eq 0 ]; then
+        echo -e "${GREEN}✓ $STRATEGY concluída com sucesso!${NC}"
+        echo "Status: SUCESSO" >> $MAIN_LOG
+    else
+        echo -e "${RED}✗ Erro ao executar $STRATEGY${NC}"
+        echo "Status: ERRO" >> $MAIN_LOG
+    fi
+    
+    echo "Fim: $(date)" >> $MAIN_LOG
+    
+    # Copiar resultados para diretório consolidado
+    echo -e "${YELLOW}Copiando resultados...${NC}"
+    
+    # Criar subdiretório para a estratégia
+    STRATEGY_DIR="$RESULTS_DIR/$STRATEGY"
+    mkdir -p $STRATEGY_DIR
+    
+    # Copiar arquivos de resultados
+    if [ -d "results" ]; then
+        cp -r results/* $STRATEGY_DIR/ 2>/dev/null
+    fi
+    
+    # Copiar métricas dos clientes
+    if [ -d "metrics" ]; then
+        cp -r metrics $STRATEGY_DIR/ 2>/dev/null
+    fi
+    
+    # Copiar logs
+    cp *_$STRATEGY.log $STRATEGY_DIR/ 2>/dev/null
+    
+    # Renomear arquivos para incluir estratégia
+    if [ -f "results/detailed_metrics_$STRATEGY.csv" ]; then
+        cp "results/detailed_metrics_$STRATEGY.csv" "$RESULTS_DIR/metrics_$STRATEGY.csv"
+    fi
+    
+    # Aguardar antes da próxima estratégia
+    echo -e "${YELLOW}Aguardando 5 segundos antes da próxima estratégia...${NC}"
+    sleep 5
+done
+
+echo -e "\n${PURPLE}════════════════════════════════════════════════════════${NC}"
+echo -e "${PURPLE}     GERANDO ANÁLISE COMPARATIVA FINAL${NC}"
+echo -e "${PURPLE}════════════════════════════════════════════════════════${NC}"
+
+# Mover todos os CSVs de métricas para results/
+echo -e "${YELLOW}Consolidando métricas...${NC}"
+cp $RESULTS_DIR/metrics_*.csv results/ 2>/dev/null
+
+# Executar análise comparativa final
+echo -e "${GREEN}Executando análise comparativa...${NC}"
+python analysis_tool.py --results-dir results
+
+# Copiar análise comparativa para diretório consolidado
+if [ -f "results/comparative_analysis.pdf" ]; then
+    cp results/comparative_analysis.pdf $RESULTS_DIR/
+    echo -e "${GREEN}✓ Análise comparativa gerada!${NC}"
+fi
+
+if [ -f "results/summary_report.json" ]; then
+    cp results/summary_report.json $RESULTS_DIR/
+fi
+
+# Criar relatório resumido em texto
+SUMMARY_FILE="$RESULTS_DIR/summary.txt"
+echo "════════════════════════════════════════════════════════" > $SUMMARY_FILE
+echo "     RESUMO DA COMPARAÇÃO DE ESTRATÉGIAS FL" >> $SUMMARY_FILE
+echo "════════════════════════════════════════════════════════" >> $SUMMARY_FILE
+echo "" >> $SUMMARY_FILE
+echo "Data: $(date)" >> $SUMMARY_FILE
+echo "Rodadas: $ROUNDS" >> $SUMMARY_FILE
+echo "Tamanho da Previsão: $PREDICTION_LENGTH passos" >> $SUMMARY_FILE
+echo "" >> $SUMMARY_FILE
+echo "RESULTADOS POR ESTRATÉGIA:" >> $SUMMARY_FILE
+echo "----------------------------" >> $SUMMARY_FILE
+
+# Extrair métricas finais de cada estratégia
+for STRATEGY in "${STRATEGIES[@]}"; do
+    echo "" >> $SUMMARY_FILE
+    echo "[$STRATEGY]" >> $SUMMARY_FILE
+    
+    LOG_FILE="$STRATEGY_DIR/$STRATEGY/server_$STRATEGY.log"
+    if [ -f "$LOG_FILE" ]; then
+        FINAL_TRAIN=$(grep "Perda final de treino:" "$LOG_FILE" | tail -1 | grep -oE "[0-9]+\.[0-9]+" | head -1)
+        FINAL_VAL=$(grep "Perda final de validação:" "$LOG_FILE" | tail -1 | grep -oE "[0-9]+\.[0-9]+" | head -1)
+        IMPROVEMENT=$(grep "Melhoria no treino:" "$LOG_FILE" | tail -1 | grep -oE "[0-9]+\.[0-9]+%" | head -1)
+        
+        echo "  Perda Final (Treino): ${FINAL_TRAIN:-N/A}" >> $SUMMARY_FILE
+        echo "  Perda Final (Validação): ${FINAL_VAL:-N/A}" >> $SUMMARY_FILE
+        echo "  Melhoria: ${IMPROVEMENT:-N/A}" >> $SUMMARY_FILE
+    else
+        echo "  Status: Dados não disponíveis" >> $SUMMARY_FILE
+    fi
+done
+
+echo "" >> $SUMMARY_FILE
+echo "════════════════════════════════════════════════════════" >> $SUMMARY_FILE
+
+# Exibir resumo no terminal
+cat $SUMMARY_FILE
+
+# Estatísticas finais
+echo -e "\n${PURPLE}════════════════════════════════════════════════════════${NC}"
+echo -e "${PURPLE}     EXECUÇÃO COMPLETA${NC}"
+echo -e "${PURPLE}════════════════════════════════════════════════════════${NC}"
+
+echo -e "\n${GREEN}Resultados salvos em: ${YELLOW}$RESULTS_DIR/${NC}"
+echo -e "${GREEN}Estrutura de arquivos:${NC}"
+echo -e "  ${YELLOW}$RESULTS_DIR/${NC}"
+echo -e "    ├── ${BLUE}summary.txt${NC} - Resumo geral"
+echo -e "    ├── ${BLUE}execution_log.txt${NC} - Log de execução"
+echo -e "    ├── ${BLUE}comparative_analysis.pdf${NC} - Análise comparativa"
+echo -e "    ├── ${BLUE}summary_report.json${NC} - Relatório detalhado"
+
+for STRATEGY in "${STRATEGIES[@]}"; do
+    echo -e "    ├── ${GREEN}$STRATEGY/${NC}"
+    echo -e "    │   ├── Resultados específicos"
+    echo -e "    │   ├── Métricas dos clientes"
+    echo -e "    │   └── Logs de execução"
+done
+
+echo -e "\n${YELLOW}Visualizações disponíveis:${NC}"
+echo -e "  • ${GREEN}comparative_analysis.pdf${NC} - Comparação entre estratégias"
+echo -e "  • ${GREEN}client_evolution_analysis.pdf${NC} - Evolução dos clientes"
+echo -e "  • ${GREEN}performance_analysis_*.pdf${NC} - Análise por estratégia"
+echo -e "  • ${GREEN}convergence_analysis_*.pdf${NC} - Análise de convergência"
+echo -e "  • ${GREEN}heatmap_performance_*.pdf${NC} - Mapas de calor"
+
+# Determinar melhor estratégia
+echo -e "\n${PURPLE}════════════════════════════════════════════════════════${NC}"
+echo -e "${PURPLE}     MELHOR ESTRATÉGIA${NC}"
+echo -e "${PURPLE}════════════════════════════════════════════════════════${NC}"
+
+BEST_STRATEGY=""
+BEST_LOSS=999999
+
+for STRATEGY in "${STRATEGIES[@]}"; do
+    CSV_FILE="results/detailed_metrics_$STRATEGY.csv"
+    if [ -f "$CSV_FILE" ]; then
+        # Pegar última linha com fase 'eval' e coluna 'global_eval_loss'
+        FINAL_LOSS=$(tail -n 20 "$CSV_FILE" | grep "eval" | tail -1 | cut -d',' -f3)
+        
+        if [ ! -z "$FINAL_LOSS" ]; then
+            # Comparar usando bc para números decimais
+            if (( $(echo "$FINAL_LOSS < $BEST_LOSS" | bc -l) )); then
+                BEST_LOSS=$FINAL_LOSS
+                BEST_STRATEGY=$STRATEGY
+            fi
+        fi
+    fi
+done
+
+if [ ! -z "$BEST_STRATEGY" ]; then
+    echo -e "${GREEN}Melhor estratégia: ${YELLOW}$BEST_STRATEGY${NC}"
+    echo -e "${GREEN}Perda final de validação: ${YELLOW}$BEST_LOSS${NC}"
+else
+    echo -e "${YELLOW}Não foi possível determinar a melhor estratégia${NC}"
+fi
+
+echo -e "\n${BLUE}════════════════════════════════════════════════════════${NC}"
+echo -e "${GREEN}✓ Comparação completa de todas as estratégias!${NC}"
+echo -e "${BLUE}════════════════════════════════════════════════════════${NC}"
+
+# Fim
+echo "Execução finalizada em: $(date)" >> $MAIN_LOG
+exit 0

server.py

@@ -0,0 +1,449 @@
+import argparse
+import flwr as fl
+import torch
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from typing import List, Tuple, Dict, Optional
+from flwr.common import Metrics, ndarrays_to_parameters 
+from pathlib import Path
+import json
+from datetime import datetime
+
+from utils import Net
+
+# Configurações de visualização
+plt.style.use('seaborn-v0_8-darkgrid')
+sns.set_palette("husl")
+
+# Dicionário de estratégias disponíveis
+STRATEGIES = {
+    "fedavg": fl.server.strategy.FedAvg,
+    "fedadam": fl.server.strategy.FedAdam,
+    "fedyogi": fl.server.strategy.FedYogi,
+    "fedadagrad": fl.server.strategy.FedAdagrad,
+}
+
+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 = {
+            "rounds": [],
+            "global_train_loss": [],
+            "client_1_train_loss": [],
+            "client_2_train_loss": [],
+            "client_3_train_loss": []
+        }
+        self.eval_metrics = {
+            "rounds": [],
+            "global_eval_loss": [],
+            "client_1_eval_loss": [],
+            "client_2_eval_loss": [],
+            "client_3_eval_loss": []
+        }
+        self.convergence_metrics = {
+            "rounds": [],
+            "loss_variance": [],
+            "loss_std": [],
+            "max_min_diff": []
+        }
+        
+    def add_train_round(self, round_num, metrics):
+        """Adiciona métricas de uma rodada de treinamento."""
+        self.train_metrics["rounds"].append(round_num)
+        for key, value in metrics.items():
+            if key in self.train_metrics:
+                self.train_metrics[key].append(value)
+    
+    def add_eval_round(self, round_num, metrics):
+        """Adiciona métricas de uma rodada de avaliação."""
+        self.eval_metrics["rounds"].append(round_num)
+        for key, value in metrics.items():
+            if key in self.eval_metrics:
+                self.eval_metrics[key].append(value)
+    
+    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
+
+def weighted_average(metrics: List[Tuple[int, Metrics]]) -> Dict[str, any]:
+    """Função de agregação para métricas de avaliação."""
+    individual_losses = {}
+    
+    for num_examples, m in metrics:
+        client_id = m.get("client_id", 0)
+        if client_id > 0:
+            individual_losses[f"client_{client_id}_eval_loss"] = m["loss"]
+    
+    # Calcula média ponderada
+    losses = [num_examples * m["loss"] for num_examples, m in metrics]
+    examples = [num_examples for num_examples, _ in metrics]
+    avg_loss = sum(losses) / sum(examples) if sum(examples) > 0 else 0
+    
+    aggregated_metrics = {"global_eval_loss": avg_loss}
+    aggregated_metrics.update(individual_losses)
+    
+    return aggregated_metrics
+
+def fit_metrics_aggregator(metrics: List[Tuple[int, Metrics]]) -> Dict[str, float]:
+    """Agrega métricas de treinamento."""
+    individual_losses = {}
+    
+    for num_examples, m in metrics:
+        client_id = m.get("client_id", 0)
+        if client_id > 0:
+            individual_losses[f"client_{client_id}_train_loss"] = m["train_loss"]
+    
+    losses = [num_examples * m["train_loss"] for num_examples, m in metrics]
+    examples = [num_examples for num_examples, _ in metrics]
+    
+    avg_loss = sum(losses) / sum(examples) if sum(examples) > 0 else 0
+    
+    aggregated_metrics = {"global_train_loss": avg_loss}
+    aggregated_metrics.update(individual_losses)
+    
+    return aggregated_metrics
+
+def create_visualizations(collector: MetricsCollector, output_dir: Path):
+    """Cria todas as visualizações de desempenho."""
+    
+    # 1. Gráfico de Comparação Geral (Treino vs Validação - Global e Clientes)
+    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
+    
+    # Subplot 1: Desempenho Global
+    ax1 = axes[0, 0]
+    rounds = collector.train_metrics["rounds"]
+    ax1.plot(rounds, collector.train_metrics["global_train_loss"], 
+             'b-', marker='s', label='Treino Global', linewidth=2)
+    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 i in range(1, 4):
+        key = f"client_{i}_train_loss"
+        if key in collector.train_metrics and collector.train_metrics[key]:
+            ax2.plot(rounds, collector.train_metrics[key], 
+                    marker='o', label=f'Cliente {i}', color=colors[i-1], linewidth=1.5)
+    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]
+    for i in range(1, 4):
+        key = f"client_{i}_eval_loss"
+        if key in collector.eval_metrics and collector.eval_metrics[key]:
+            ax3.plot(collector.eval_metrics["rounds"], collector.eval_metrics[key], 
+                    marker='s', label=f'Cliente {i}', color=colors[i-1], linewidth=1.5)
+    ax3.plot(collector.eval_metrics["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:
+        train_improvement = np.diff(collector.train_metrics["global_train_loss"])
+        eval_improvement = np.diff(collector.eval_metrics["global_eval_loss"])
+        ax4.plot(rounds[1:], train_improvement, 'g-', marker='v', label='Δ Treino', linewidth=1.5)
+        ax4.plot(collector.eval_metrics["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()
+    
+    # 2. Gráfico de Convergência e Heterogeneidade
+    fig, axes = plt.subplots(1, 3, figsize=(18, 6))
+    
+    # Calcular métricas de convergência
+    for round_idx, round_num in enumerate(rounds):
+        client_losses = []
+        for i in range(1, 4):
+            key = f"client_{i}_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 client_losses:
+            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)
+    
+    # Subplot 1: Variância entre clientes
+    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)
+    
+    # Subplot 2: Desvio padrão
+    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)
+    
+    # Subplot 3: Diferença máx-mín
+    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)
+    
+    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()
+    
+    # 3. Heatmap de desempenho por cliente ao longo do tempo
+    fig, ax = plt.subplots(figsize=(12, 6))
+    
+    # Preparar dados para heatmap
+    heatmap_data = []
+    for i in range(1, 4):
+        key = f"client_{i}_eval_loss"
+        if key in collector.eval_metrics:
+            heatmap_data.append(collector.eval_metrics[key])
+    
+    if heatmap_data:
+        heatmap_array = np.array(heatmap_data)
+        im = ax.imshow(heatmap_array, aspect='auto', cmap='RdYlGn_r')
+        
+        ax.set_xticks(range(len(collector.eval_metrics["rounds"])))
+        ax.set_xticklabels(collector.eval_metrics["rounds"])
+        ax.set_yticks(range(3))
+        ax.set_yticklabels([f'Cliente {i}' for i in range(1, 4)])
+        
+        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')
+        
+        # Adicionar valores nas células
+        for i in range(3):
+            for j in range(len(collector.eval_metrics["rounds"])):
+                if j < len(heatmap_data[i]):
+                    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)')
+    
+    plt.tight_layout()
+    plt.savefig(output_dir / f'heatmap_performance_{collector.strategy_name}.pdf', dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    print(f"Visualizações salvas em {output_dir}")
+
+def save_detailed_metrics(collector: MetricsCollector, output_dir: Path):
+    """Salva métricas detalhadas em diferentes formatos."""
+    
+    # 1. CSV com todas as métricas
+    all_metrics = pd.DataFrame()
+    
+    # Adicionar métricas de treino
+    if collector.train_metrics["rounds"]:
+        train_df = pd.DataFrame(collector.train_metrics)
+        train_df['phase'] = 'train'
+        all_metrics = pd.concat([all_metrics, train_df], ignore_index=True)
+    
+    # Adicionar métricas de validação
+    if collector.eval_metrics["rounds"]:
+        eval_df = pd.DataFrame(collector.eval_metrics)
+        eval_df['phase'] = 'eval'
+        all_metrics = pd.concat([all_metrics, eval_df], ignore_index=True)
+    
+    # Salvar CSV detalhado
+    csv_file = output_dir / f'detailed_metrics_{collector.strategy_name}.csv'
+    all_metrics.to_csv(csv_file, index=False)
+    print(f"Métricas detalhadas salvas em {csv_file}")
+    
+    # 2. JSON com análise estatística
+    stats = {
+        "strategy": collector.strategy_name,
+        "total_rounds": len(collector.train_metrics["rounds"]),
+        "final_global_train_loss": collector.train_metrics["global_train_loss"][-1] if collector.train_metrics["global_train_loss"] else None,
+        "final_global_eval_loss": collector.eval_metrics["global_eval_loss"][-1] if collector.eval_metrics["global_eval_loss"] else None,
+        "train_improvement": (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": (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,
+        "convergence_metrics": collector.convergence_metrics,
+        "timestamp": datetime.now().isoformat()
+    }
+    
+    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}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Flower Server Enhanced")
+    parser.add_argument(
+        "--strategy", type=str, choices=list(STRATEGIES.keys()), default="fedavg",
+        help="Estratégia de agregação a ser usada."
+    )
+    parser.add_argument(
+        "--rounds", type=int, default=10, help="Número de rodadas de FL."
+    )
+    parser.add_argument(
+        "--min-clients", type=int, default=3, help="Número mínimo de clientes."
+    )
+    parser.add_argument(
+    "--prediction-length", type=int, default=10, help="Tamanho da previsão."
+    )
+    args = parser.parse_args()
+
+    print(f"Tamanho da Previsão: {args.prediction_length}")
+    # Cria uma instância do modelo no servidor para obter os parâmetros iniciais
+# Os valores de input/hidden devem ser os mesmos do cliente
+    net = Net(input_size=6, hidden_size=50, output_size=args.prediction_length)
+    initial_parameters = [val.cpu().numpy() for _, val in net.state_dict().items()]
+
+
+    print(f"\n{'='*60}")
+    print(f"SERVIDOR DE APRENDIZADO FEDERADO")
+    print(f"{'='*60}")
+    print(f"Estratégia: {args.strategy.upper()}")
+    print(f"Rodadas: {args.rounds}")
+    print(f"Clientes mínimos: {args.min_clients}")
+    print(f"{'='*60}\n")
+
+    # Cria diretórios de saída
+    output_dir = Path("results")
+    output_dir.mkdir(exist_ok=True)
+    
+    # Inicializa coletor de métricas
+    collector = MetricsCollector(args.strategy)
+    
+    # Função customizada de agregação que também coleta métricas
+    def enhanced_weighted_average(metrics: List[Tuple[int, Metrics]]) -> Dict[str, any]:
+        result = weighted_average(metrics)
+        # Coletar métricas para visualização
+        round_num = max([m.get("round", 0) for _, m in metrics])
+        if round_num > 0:
+            collector.add_eval_round(round_num, result)
+        return result
+    
+    def enhanced_fit_aggregator(metrics: List[Tuple[int, Metrics]]) -> Dict[str, float]:
+        result = fit_metrics_aggregator(metrics)
+        # Coletar métricas para visualização
+        round_num = max([m.get("round", 0) for _, m in metrics])
+        if round_num > 0:
+            collector.add_train_round(round_num, result)
+        return result
+
+    # Cria a estratégia com as funções de agregação aprimoradas
+    strategy_params = {
+    "min_fit_clients": args.min_clients,
+    "min_available_clients": args.min_clients,
+    "evaluate_metrics_aggregation_fn": enhanced_weighted_average,
+    "fit_metrics_aggregation_fn": enhanced_fit_aggregator,
+    }
+
+    if args.strategy != "fedavg":
+        strategy_params["initial_parameters"] = ndarrays_to_parameters(initial_parameters)
+
+    strategy = STRATEGIES[args.strategy](**strategy_params)
+
+
+    # Inicia o servidor
+    print("Iniciando servidor FL...")
+    history = fl.server.start_server(
+        server_address="0.0.0.0:8080",
+        config=fl.server.ServerConfig(num_rounds=args.rounds),
+        strategy=strategy,
+    )
+
+    print("\n" + "="*60)
+    print("TREINAMENTO CONCLUÍDO - GERANDO ANÁLISES")
+    print("="*60)
+    
+    # Criar visualizações
+    create_visualizations(collector, output_dir)
+    
+    # Salvar métricas detalhadas
+    save_detailed_metrics(collector, output_dir)
+    
+    # Análise final
+    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'}")
+    
+    print("\n" + "="*60)
+    print(f"Resultados salvos em: {output_dir}")
+    print("="*60)
+
+if __name__ == "__main__":
+    main()

server_fedadagrad.log

@@ -0,0 +1,213 @@
+WARNING :   DEPRECATED FEATURE: flwr.server.start_server() is deprecated.
+	Instead, use the `flower-superlink` CLI command to start a SuperLink as shown below:
+
+		$ flower-superlink --insecure
+
+	To view usage and all available options, run:
+
+		$ flower-superlink --help
+
+	Using `start_server()` is deprecated.
+
+            This is a deprecated feature. It will be removed
+            entirely in future versions of Flower.
+        
+INFO :      Starting Flower server, config: num_rounds=10, no round_timeout
+INFO :      Flower ECE: gRPC server running (10 rounds), SSL is disabled
+INFO :      [INIT]
+INFO :      Using initial global parameters provided by strategy
+INFO :      Starting evaluation of initial global parameters
+INFO :      Evaluation returned no results (`None`)
+INFO :      
+INFO :      [ROUND 1]
+INFO :      configure_fit: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_fit: received 3 results and 0 failures
+INFO :      configure_evaluate: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_evaluate: received 3 results and 0 failures
+INFO :      
+INFO :      [ROUND 2]
+INFO :      configure_fit: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_fit: received 3 results and 0 failures
+INFO :      configure_evaluate: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_evaluate: received 3 results and 0 failures
+INFO :      
+INFO :      [ROUND 3]
+INFO :      configure_fit: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_fit: received 3 results and 0 failures
+INFO :      configure_evaluate: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_evaluate: received 3 results and 0 failures
+INFO :      
+INFO :      [ROUND 4]
+INFO :      configure_fit: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_fit: received 3 results and 0 failures
+INFO :      configure_evaluate: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_evaluate: received 3 results and 0 failures
+INFO :      
+INFO :      [ROUND 5]
+INFO :      configure_fit: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_fit: received 3 results and 0 failures
+INFO :      configure_evaluate: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_evaluate: received 3 results and 0 failures
+INFO :      
+INFO :      [ROUND 6]
+INFO :      configure_fit: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_fit: received 3 results and 0 failures
+INFO :      configure_evaluate: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_evaluate: received 3 results and 0 failures
+INFO :      
+INFO :      [ROUND 7]
+INFO :      configure_fit: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_fit: received 3 results and 0 failures
+INFO :      configure_evaluate: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_evaluate: received 3 results and 0 failures
+INFO :      
+INFO :      [ROUND 8]
+INFO :      configure_fit: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_fit: received 3 results and 0 failures
+INFO :      configure_evaluate: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_evaluate: received 3 results and 0 failures
+INFO :      
+INFO :      [ROUND 9]
+INFO :      configure_fit: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_fit: received 3 results and 0 failures
+INFO :      configure_evaluate: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_evaluate: received 3 results and 0 failures
+INFO :      
+INFO :      [ROUND 10]
+INFO :      configure_fit: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_fit: received 3 results and 0 failures
+INFO :      configure_evaluate: strategy sampled 3 clients (out of 3)
+INFO :      aggregate_evaluate: received 3 results and 0 failures
+INFO :      
+INFO :      [SUMMARY]
+INFO :      Run finished 10 round(s) in 146.09s
+INFO :      	History (loss, distributed):
+INFO :      		round 1: 9.925077960899166
+INFO :      		round 2: 1.3836319349268043
+INFO :      		round 3: 0.29234505289901225
+INFO :      		round 4: 0.49308163151779894
+INFO :      		round 5: 0.0446630789378426
+INFO :      		round 6: 0.284914885456677
+INFO :      		round 7: 0.058860671314457845
+INFO :      		round 8: 0.07942846971222137
+INFO :      		round 9: 0.037627383500482725
+INFO :      		round 10: 0.024166644675821698
+INFO :      	History (metrics, distributed, fit):
+INFO :      	{'client_1_train_loss': [(1, 0.011821450406897624),
+INFO :      	                         (2, 9.19087529878669),
+INFO :      	                         (3, 0.6059146807741652),
+INFO :      	                         (4, 0.19704961071376878),
+INFO :      	                         (5, 0.13989461602253406),
+INFO :      	                         (6, 0.020903305802541017),
+INFO :      	                         (7, 0.1471804918425052),
+INFO :      	                         (8, 0.03622452800638312),
+INFO :      	                         (9, 0.021778890335108998),
+INFO :      	                         (10, 0.014076102254991698)],
+INFO :      	 'client_2_train_loss': [(1, 0.005994700957002613),
+INFO :      	                         (2, 9.031767151078034),
+INFO :      	                         (3, 0.7539265559325762),
+INFO :      	                         (4, 0.16390307652051578),
+INFO :      	                         (5, 0.20438744467001307),
+INFO :      	                         (6, 0.016729887813302254),
+INFO :      	                         (7, 0.12536963731445314),
+INFO :      	                         (8, 0.03203308185613172),
+INFO :      	                         (9, 0.01797729913919752),
+INFO :      	                         (10, 0.014847784393701121)],
+INFO :      	 'client_3_train_loss': [(1, 0.0477309877821325),
+INFO :      	                         (2, 8.576512244819956),
+INFO :      	                         (3, 0.7021478945708147),
+INFO :      	                         (4, 0.20970996846132312),
+INFO :      	                         (5, 0.2520780406049325),
+INFO :      	                         (6, 0.039224337560547065),
+INFO :      	                         (7, 0.19049448489231752),
+INFO :      	                         (8, 0.03907830891323567),
+INFO :      	                         (9, 0.03410547275085612),
+INFO :      	                         (10, 0.03132038051823111)],
+INFO :      	 'global_train_loss': [(1, 0.024723581809669777),
+INFO :      	                       (2, 8.885175558524038),
+INFO :      	                       (3, 0.6942090508692439),
+INFO :      	                       (4, 0.19139092719798328),
+INFO :      	                       (5, 0.20735043383995075),
+INFO :      	                       (6, 0.027091810488224646),
+INFO :      	                       (7, 0.15788991120164078),
+INFO :      	                       (8, 0.03602586002639032),
+INFO :      	                       (9, 0.025616361683664917),
+INFO :      	                       (10, 0.021443837521512663)]}
+INFO :      	History (metrics, distributed, evaluate):
+INFO :      	{'client_1_eval_loss': [(1, 9.976542702888077),
+INFO :      	                        (2, 1.2864945372182275),
+INFO :      	                        (3, 0.2793154488706755),
+INFO :      	                        (4, 0.5965077027088073),
+INFO :      	                        (5, 0.03825337379663002),
+INFO :      	                        (6, 0.2677974948383068),
+INFO :      	                        (7, 0.058361862074286265),
+INFO :      	                        (8, 0.08157266843303032),
+INFO :      	                        (9, 0.029206974828750388),
+INFO :      	                        (10, 0.02422947784015051)],
+INFO :      	 'client_2_eval_loss': [(1, 10.00263674723258),
+INFO :      	                        (2, 1.3619409297631837),
+INFO :      	                        (3, 0.24040741897930812),
+INFO :      	                        (4, 0.38867445768531034),
+INFO :      	                        (5, 0.032692949841941314),
+INFO :      	                        (6, 0.2738929928920669),
+INFO :      	                        (7, 0.060165285674857814),
+INFO :      	                        (8, 0.07285282868754381),
+INFO :      	                        (9, 0.029050754143804952),
+INFO :      	                        (10, 0.01716736676326117)],
+INFO :      	 'client_3_eval_loss': [(1, 9.831531776215563),
+INFO :      	                        (2, 1.461328144772189),
+INFO :      	                        (3, 0.3416395899531878),
+INFO :      	                        (4, 0.5114476139352474),
+INFO :      	                        (5, 0.05814581121184792),
+INFO :      	                        (6, 0.3043146318768071),
+INFO :      	                        (7, 0.058136951014934914),
+INFO :      	                        (8, 0.08330663724478181),
+INFO :      	                        (9, 0.049671815384144585),
+INFO :      	                        (10, 0.029676996694472633)],
+INFO :      	 'global_eval_loss': [(1, 9.925078071091885),
+INFO :      	                      (2, 1.3836319280429141),
+INFO :      	                      (3, 0.29234505846417363),
+INFO :      	                      (4, 0.4930816239130249),
+INFO :      	                      (5, 0.0446630791944702),
+INFO :      	                      (6, 0.2849148775837404),
+INFO :      	                      (7, 0.058860671175644294),
+INFO :      	                      (8, 0.07942846919600849),
+INFO :      	                      (9, 0.03762738416111641),
+INFO :      	                      (10, 0.024166644736454038)]}
+INFO :      
+Tamanho da Previs�o: 90
+
+============================================================
+SERVIDOR DE APRENDIZADO FEDERADO
+============================================================
+Estrat�gia: FEDADAGRAD
+Rodadas: 10
+Clientes m�nimos: 3
+============================================================
+
+Iniciando servidor FL...
+
+============================================================
+TREINAMENTO CONCLU�DO - GERANDO AN�LISES
+============================================================
+Visualiza��es salvas em results
+M�tricas detalhadas salvas em results\detailed_metrics_fedadagrad.csv
+An�lise estat�stica salva em results\analysis_fedadagrad.json
+
+============================================================
+RESUMO DO TREINAMENTO
+============================================================
+Perda inicial de treino: 0.024724
+Perda final de treino: 0.021444
+Melhoria no treino: 13.27%
+
+Perda inicial de valida��o: 9.925078
+Perda final de valida��o: 0.024167
+Melhoria na valida��o: 99.76%
+
+Desvio padr�o final entre clientes: 0.005121
+Converg�ncia: Boa
+
+============================================================
+Resultados salvos em: results
+============================================================

utils.py

@@ -0,0 +1,139 @@
+import pandas as pd
+import numpy as np
+import torch
+from torch.utils.data import TensorDataset, DataLoader
+from sklearn.preprocessing import MinMaxScaler
+from pathlib import Path
+import os
+
+# Definição do Modelo LSTM com PyTorch
+class Net(torch.nn.Module):
+    def __init__(self, input_size, hidden_size, output_size, num_layers=1):
+        super(Net, self).__init__()
+        self.lstm = torch.nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
+        self.linear = torch.nn.Linear(hidden_size, output_size)
+
+    def forward(self, x):
+        lstm_out, _ = self.lstm(x)
+        # Usamos apenas a saída do último passo de tempo para a previsão
+        last_time_step_out = lstm_out[:, -1, :]
+        out = self.linear(last_time_step_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] # A última coluna é 'P_kW'
+        xs.append(x)
+        ys.append(y)
+    return np.array(xs), np.array(ys)
+
+def load_data(client_id: int, sequence_length=60, prediction_length=30, batch_size=32):
+    """
+    Carrega os dados para um cliente específico, processa e retorna DataLoaders.
+    NOVA VERSÃO: Concatena todos os percursos e divide em 80% para treino e 20% para teste.
+    """
+    data_dir = Path(f"data/client_{client_id}")
+    
+    # 1. Carrega todos os percursos em uma lista de DataFrames
+    all_routes_df = [pd.read_csv(f) for f in data_dir.glob("*.csv")]
+
+    if not all_routes_df:
+        raise FileNotFoundError(f"Nenhum arquivo CSV encontrado para o cliente {client_id} no diretório {data_dir}")
+
+    # 2. Concatena TODOS os percursos em um único DataFrame
+    combined_df = pd.concat(all_routes_df, ignore_index=True)
+
+    feature_columns = ['vehicle_speed', 'engine_rpm', 'accel_x', 'accel_y', 'P_kW', 'dt']
+    processed_df = combined_df[feature_columns].dropna()
+
+    # 3. Divide o DataFrame combinado em 80% para treino e 20% para teste
+    split_index = int(len(processed_df) * 0.8)
+    train_df = processed_df.iloc[:split_index]
+    test_df = processed_df.iloc[split_index:]
+
+    # 4. AJUSTA O SCALER APENAS NOS DADOS DE TREINO (ESSENCIAL!)
+    scaler = MinMaxScaler()
+    scaler.fit(train_df)
+
+    # 5. TRANSFORMA AMBOS OS CONJUNTOS COM O SCALER AJUSTADO
+    train_scaled = scaler.transform(train_df)
+    test_scaled = scaler.transform(test_df)
+
+    # 6. CRIA JANELAS SEPARADAMENTE PARA TREINO E TESTE
+    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)
+    
+    # Garante que os conjuntos não sejam vazios
+    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 de treino ou teste vazio. Verifique a quantidade de dados.")
+
+    # Conversão para tensores PyTorch
+    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()
+
+    # Criação de DataLoaders
+    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]
+
+    return trainloader, testloader, num_features
+
+
+def train(net, trainloader, epochs, device):
+    """Treina e retorna a perda média por amostra (float)."""
+    criterion = torch.nn.MSELoss(reduction="mean")  # perda média por saída
+    optimizer = torch.optim.Adam(net.parameters(), lr=1e-5)
+    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)  # média por amostra no batch
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(net.parameters(), max_norm=1.0)
+            optimizer.step()
+
+            batch_size = sequences.size(0)
+            total_loss_sum += loss.item() * batch_size  # soma por amostra
+            total_samples += batch_size
+
+    if total_samples == 0:
+        return 0.0
+    return total_loss_sum / total_samples  # média por amostra
+
+# --- substitua a função test ---
+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