app.py

import streamlit as st
import matplotlib.pyplot as plt
import networkx as nx
import numpy as np
from matplotlib.animation import FuncAnimation
import pandas as pd
import time
import plotly.graph_objects as go
import plotly.express as px
from io import BytesIO

st.set_page_config(page_title="APRENDIZADO FEDERADO PARA PREVISÃO DE DEMANDA ENERGÉTICA", page_icon=":bar_chart:", layout="wide", initial_sidebar_state="auto")

st.markdown("<h2 style='text-align: center;'>Aprendizado Federado com Flower</h2>", unsafe_allow_html=True)
st.sidebar.image("images/logo_inmetro.jpg", width=200)
st.sidebar.title("FL Inmetro")

secao = st.sidebar.radio("Ir para:", ["🏠 Início", "🖥️ Implementação", "📊 Visualização", "🍓 Integração Raspberry Pi", "📈 Modelos para EVs", "📚 Artigos", "ℹ️ Sobre"])

if secao == "🏠 Início":

    tab1, tab2, tab3 = st.tabs(["📘 Aprendizado Centralizado", "📗 Aprendizado Federado", "O Projeto"])

    with tab1:
        st.markdown("## 📘 Aprendizado Centralizado: Fundamentos Teóricos")
        
        # Definição formal do problema
        st.markdown("### 🔍 Definição Formal do Problema")
        st.latex(r"""
        \begin{aligned}
        &\text{Dado:} \\
        &\quad \text{Conjunto de dados } \mathcal{D} = \{(\mathbf{x}_i, y_i)\}_{i=1}^N \\
        &\quad \text{Modelo paramétrico } f_\theta: \mathcal{X} \to \mathcal{Y} \\
        &\quad \text{Função perda } \ell: \mathcal{Y} \times \mathcal{Y} \to \mathbb{R}^+ \\
        \\
        &\text{Objetivo:} \\
        &\quad \min_{\theta \in \mathbb{R}^d} \mathcal{L}(\theta) = \mathbb{E}_{(\mathbf{x},y) \sim \mathcal{P}} [\ell(f_\theta(\mathbf{x}), y)] \\
        &\quad \text{com aproximação empírica:} \\
        &\quad \hat{\mathcal{L}}(\theta) = \frac{1}{N} \sum_{i=1}^N \ell(f_\theta(\mathbf{x}_i), y_i)
        \end{aligned}
        """)
        
        st.markdown("""
        Onde:
        - $\mathcal{P}$ é a distribuição de dados subjacente
        - $\mathbf{x}_i \in \mathbb{R}^m$ são features de entrada
        - $y_i \in \mathcal{Y}$ são targets (contínuos ou discretos)
        - $\theta$ são parâmetros do modelo (e.g., pesos de rede neural)
        """)
        
        # Fundamentos de otimização
        st.markdown("#### Algoritmo: Gradiente Descendente (GD)")
        st.latex(r"""
        \begin{aligned}
        &\textbf{Input: } \theta_0 \text{ (inicialização)}, \eta > 0 \text{ (taxa aprendizado)}, T \\
        &\textbf{For } t = 0 \text{ to } T-1: \\
        &\quad g_t = \nabla_\theta \hat{\mathcal{L}}(\theta_t) = \frac{1}{N} \sum_{i=1}^N \nabla_\theta \ell(f_{\theta_t}(\mathbf{x}_i), y_i) \\
        &\quad \theta_{t+1} = \theta_t - \eta g_t
        \end{aligned}
        """)
        
        st.markdown("#### Formulação Estocástica (SGD)")
        st.latex(r"""
        \begin{aligned}
        &\textbf{Input: } \theta_0, \eta > 0, T, \text{ tamanho lote } B \\
        &\textbf{For } t = 0 \text{ to } T-1: \\
        &\quad \text{Selecione } \mathcal{B}_t \subset \{1,\dots,N\} \text{ com } |\mathcal{B}_t| = B \\
        &\quad \tilde{g}_t = \frac{1}{B} \sum_{i \in \mathcal{B}_t} \nabla_\theta \ell(f_{\theta_t}(\mathbf{x}_i), y_i) \\
        &\quad \theta_{t+1} = \theta_t - \eta \tilde{g}_t
        \end{aligned}
        """)
        
        # Análise de convergência
        st.markdown("### Convergência")
        st.latex(r"""
        \text{Sob as condições:} \\
        \begin{array}{ll}
        (1) & \mathcal{L} \text{ é } \mu\text{-fortemente convexa} \\
        (2) & \mathbb{E}[\|\nabla_\theta \ell(\cdot)\|^2_2] \leq G^2 \\
        (3) & \eta_t = \frac{c}{t} \text{ (decay de taxa de aprendizado)}
        \end{array}
        """)
        st.latex(r"""
        \text{GD atinge:} \\
        \mathcal{L}(\theta_T) - \mathcal{L}(\theta^*) \leq \mathcal{O}\left(\frac{1}{T}\right)
        """)
        st.latex(r"""
        \text{SGD atinge:} \\
        \mathbb{E}[\mathcal{L}(\theta_T)] - \mathcal{L}(\theta^*) \leq \mathcal{O}\left(\frac{1}{\sqrt{T}}\right)
        """)
                
        # Exemplo numérico
        st.markdown("### 🔢 Exemplo Numérico")
        st.markdown("Considere regressão linear com perda MSE:")
        st.latex(r"""
        \ell(f_\theta(\mathbf{x}), y) = \frac{1}{2} (\theta^\top \mathbf{x} - y)^2
        """)
        st.markdown("Gradiente para um único ponto:")
        st.latex(r"""
        \nabla_\theta \ell = (\theta^\top \mathbf{x} - y) \mathbf{x}
        """)
        
        st.markdown("Atualização de GD em tempo real:")
        theta = st.slider("Parâmetro θ", -2.0, 2.0, 0.5, 0.1)
        eta = st.slider("Taxa aprendizado η", 0.01, 1.0, 0.1, 0.01)
        
        # Cálculo de exemplo
        x, y = 2.0, 3.0  # Dado fixo para demonstração
        loss = 0.5 * (theta*x - y)**2
        gradient = (theta*x - y)*x
        new_theta = theta - eta*gradient
        
        st.latex(fr"""
        \begin{{aligned}}
        \theta^{{(t)}} &= {theta:.2f} \\
        \nabla_\theta \mathcal{{L}} &= ({theta:.2f} \times {x} - {y}) \times {x} = {gradient:.2f} \\
        \theta^{{(t+1)}} &= {theta:.2f} - {eta} \times {gradient:.2f} = {new_theta:.2f}
        \end{{aligned}}
        """)

    with tab2:
        st.markdown("## Aprendizado Federado: Fundamentos Teóricos")
        
        # Definição formal do problema
        st.markdown("### Formulação Matemática do Problema")
        st.latex(r"""
        \begin{aligned}
        &\text{Dado:} \\
        &\quad \text{Clientes } k = 1, \dots, K \text{ com conjuntos de dados locais } \mathcal{D}_k = \{(\mathbf{x}_i^k, y_i^k)\}_{i=1}^{n_k} \\
        &\quad \text{Modelo paramétrico } f_\theta: \mathcal{X} \to \mathcal{Y} \\
        &\quad \text{Função perda } \ell: \mathcal{Y} \times \mathcal{Y} \to \mathbb{R}^+ \\
        \\
        &\text{Objetivo Federado:} \\
        &\quad \min_{\theta \in \mathbb{R}^d} \mathcal{L}(\theta) = \sum_{k=1}^K \frac{n_k}{n} \mathcal{L}_k(\theta) \\
        &\quad \text{onde } \mathcal{L}_k(\theta) = \frac{1}{n_k} \sum_{i=1}^{n_k} \ell(f_\theta(\mathbf{x}_i^k), y_i^k) \\
        &\quad n = \sum_{k=1}^K n_k \quad \text{(tamanho total do dataset)}
        \end{aligned}
        """)
        
        st.markdown("""
        Onde:
        - $\mathcal{D}_k$ permanece localizado no dispositivo do cliente $k$
        - $n_k$ é o número de amostras do cliente $k$
        - O objetivo global é uma média ponderada dos objetivos locais
        """)
        
        # Algoritmo FedAvg detalhado
        st.markdown("### Algoritmo Federado: FedAvg (Federated Averaging)")
        st.latex(r"""
        \begin{aligned}
        1. & \textbf{Inicialização:} \\
        & \quad \theta^{(0)} \leftarrow \text{parâmetros iniciais} \\
        2. & \textbf{for } t = 0 \text{ to } T-1 \textbf{ do:} \\
        3. & \quad \text{Servidor seleciona subconjunto } S_t \subseteq \{1,\dots,K\} \\
        4. & \quad \text{Servidor transmite } \theta^{(t)} \text{ para todos os clientes } k \in S_t \\
        5. & \quad \textbf{for cada cliente } k \in S_t \textbf{ paralelamente do:} \\
        6. & \quad\quad \theta_k^{(t,0)} \leftarrow \theta^{(t)} \\
        7. & \quad\quad \textbf{for } \tau = 0 \text{ to } E-1 \textbf{ do:} \\
        8. & \quad\quad\quad \text{Selecione lote } \mathcal{B}_{\tau}^k \subseteq \mathcal{D}_k \\
        9. & \quad\quad\quad g_k^{(\tau)} = \frac{1}{|\mathcal{B}_{\tau}^k|} \sum_{(\mathbf{x},y)\in\mathcal{B}_{\tau}^k} \nabla_\theta \ell(f_{\theta_k^{(t,\tau)}}(\mathbf{x}), y) \\
        10. & \quad\quad\quad \theta_k^{(t,\tau+1)} = \theta_k^{(t,\tau)} - \eta_k g_k^{(\tau)} \\
        11. & \quad\quad \text{Cliente } k \text{ envia } \Delta_k^{(t)} = \theta_k^{(t,E)} - \theta^{(t)} \text{ para servidor} \\
        12. & \quad \text{Servidor atualiza: } \\
        & \quad\quad \theta^{(t+1)} = \theta^{(t)} + \sum_{k \in S_t} \frac{n_k}{\sum_{j \in S_t} n_j} \Delta_k^{(t)}
        \end{aligned}
        """)
        
        st.markdown("""
        Parâmetros-chave:
        - $E$: Número de épocas locais
        - $\eta_k$: Taxa de aprendizado do cliente $k$
        - $S_t$: Subconjunto de clientes na rodada $t$
        - $\Delta_k^{(t)}$: Atualização do cliente $k$
        """)
        
        # Diagrama de arquitetura
        st.markdown("### Arquitetura do Sistema Federado")
        st.image("./images/fedlr_diagram.png", width=700)
        st.markdown("""
        Fluxo de operação:
        1. Servidor inicializa modelo global $\theta^{(0)}$
        2. A cada rodada $t$:
            a. Servidor seleciona subconjunto de clientes $S_t$
            b. Envia modelo global atual para clientes selecionados
            c. Cada cliente atualiza modelo localmente com seus dados
            d. Clientes enviam atualizações de parâmetros para servidor
            e. Servidor agrega atualizações e calcula novo modelo global
        """)
        
        # Teoria de convergência
        st.markdown("### Análise de Convergência")
        st.markdown("#### Hipóteses Fundamentais")
        st.latex(r"""
        \begin{array}{ll}
        \text{(A1)} & \mathcal{L} \text{ é } L\text{-suave: } \|\nabla\mathcal{L}(\theta) - \nabla\mathcal{L}(\theta')\| \leq L\|\theta - \theta'\| \\
        \text{(A2)} & \text{Variância limitada: } \mathbb{E}_{k} \|\nabla\mathcal{L}_k(\theta) - \nabla\mathcal{L}(\theta)\|^2 \leq \sigma^2 \\
        \text{(A3)} & \text{Conjunto de dados não-IID: } \exists \delta \geq 0 \text{ tal que } \frac{1}{K}\sum_{k=1}^K \|\nabla\mathcal{L}_k(\theta) - \nabla\mathcal{L}(\theta)\|^2 \leq \delta^2 \\
        \text{(A4)} & \text{Gradiente limitado: } \mathbb{E} \|g_k^{(\tau)}\|^2 \leq G^2
        \end{array}
        """)
        
        st.markdown("#### Teorema de Convergência (FedAvg)")
        st.latex(r"""
        \text{Sob as hipóteses (A1)-(A4), com } \eta_k = \eta \text{ e seleção uniforme de clientes:}
        """)
        st.latex(r"""
        \min_{t \in \{0,\dots,T-1\}} \mathbb{E} \|\nabla \mathcal{L}(\theta^{(t)})\|^2 \leq \mathcal{O}\left( \frac{\mathcal{L}(\theta^{(0)}) - \mathcal{L}^*}{\eta E T} \right) + \mathcal{O}\left( \frac{\sigma^2}{M} \right) + \mathcal{O}\left( \eta^2 E^2 G^2 L^2 \right) + \mathcal{O}(\delta^2)
        """)
        st.markdown("""
        Onde:
        - $M = |S_t|$ (tamanho do subconjunto de clientes)
        - $\mathcal{L}^*$ é o valor ótimo da função de perda
        - $\delta$ mede o grau de heterogeneidade dos dados
        """)
        
        # Desafios técnicos detalhados
        st.markdown("### Desafios Técnicos e Soluções")
        
        st.markdown("#### 1. Heterogeneidade de Dados (não-IID)")
        st.latex(r"""
        \text{Definição: } \exists k \neq j: \mathbb{P}_k(\mathbf{x}, y) \neq \mathbb{P}_j(\mathbf{x}, y)
        """)
        st.latex(r"""
        \text{Problemas: }\\
        \text{Viés na agregação: } \mathbb{E}[\theta^{(t+1)}] \neq \theta_{\text{ótimo}}\\
        \text{Divergência do modelo: } \|\theta^{(t)} - \theta^*\| \text{ cresce com t}\\
        
        \text{Soluções teóricas: }\\
        \text{1. Regularização proximal: } \min_\theta \mathcal{L}_k(\theta) + \frac{\mu}{2} \|\theta - \theta^{(t)}\|^2\\
        \text{2. Controle de variância: } \Delta_k^{(t)} \leftarrow \Delta_k^{(t)} - \beta (\Delta_k^{(t)} - \Delta^{(t-1)})
        """)
        
        st.markdown("#### 3. Segurança e Privacidade")
        st.latex(r"""
        \begin{array}{c}
        \text{Ataque: } \Delta_k^{(t)} = \Delta_{\text{malicioso}} \\
        \text{Defesa: } \theta^{(t+1)} = \text{AGG}_{\gamma} \left( \{ \Delta_k^{(t)} \}_{k \in S_t} \right)
        \end{array}
        """)

        st.latex(r""" 
        \text{Mecanismos de defesa: }\\
        \text{2. DP-SGD: } g_k^{(\tau)} \leftarrow \text{Clip}(g_k^{(\tau)}, C) + \mathcal{N}(0, \sigma^2 I)\\
        """)
        st.markdown("""
        O **DP-SGD** adapta o SGD clássico para fornecer garantias de **privacidade diferencial**,
        limitando o impacto de cada amostra e adicionando ruído calibrado.
        """)

        # 1. Cálculo de gradientes por amostra
        st.markdown("**1. Cálculo de gradientes por amostra**")
        st.latex(r"""
        g_i \;=\; \nabla_\theta \,\ell\bigl(f_\theta(x_i),\,y_i\bigr)
        """)

        # 2. Clipping de gradientes
        st.markdown("**2. Clipping de gradientes**: limita a norma de cada gradiente a um máximo \(C\).")
        st.latex(r"""
        \bar g_i \;=\; \frac{g_i}{\max\!\bigl(1,\;\|g_i\|/C\bigr)}
        """)

        # 3. Soma e adição de ruído
        st.markdown("**3. Soma e adição de ruído**: soma os gradientes recortados e adiciona ruído Gaussiano.")
        st.latex(r"""
        \tilde g \;=\; \frac{1}{B}\sum_{i=1}^B \bar g_i \;+\; \mathcal{N}\!\bigl(0,\;\sigma^2 C^2 I\bigr)
        """)

        # 4. Atualização de parâmetros
        st.markdown("**4. Atualização de parâmetros** realiza o passo de descida de gradiente com o gradiente privatizado.")
        st.latex(r"""
        \theta \;\leftarrow\; \theta \;-\;\eta\,\tilde g
        """)

        st.markdown("---")
        st.markdown("""
        - **$C$** (clipping norm): controla o máximo de contribuição de uma única amostra.  
        - **$\sigma$** (noise multiplier): regula a intensidade do ruído; maior $\sigma$ → mais privacidade (menor $\epsilon$) mas potencialmente pior desempenho.  
        - **Moments Accountant**: método eficiente para juntar os gastos de privacidade de cada minibatch.
        """)
                
        # Comparação com aprendizado centralizado
        st.markdown("### Comparação Teórica: Federado vs Centralizado")
        st.latex(r"""
        \begin{array}{c|c|c}
        \text{Propriedade} & \text{Centralizado} & \text{Federado} \\
        \hline
        \text{Acesso aos dados} & \text{Completo} & \text{Nenhum} \\
        \text{Comunicação} & \mathcal{O}(N \times d) & \mathcal{O}(T \times |S_t| \times d) \\
        \text{Convergência} & \mathcal{O}(1/T) & \mathcal{O}(1/\sqrt{T}) \\
        \text{Privacidade} & \text{Baixa} & \text{Alta (com DP)} \\
        \text{Robustez} & \text{Alta} & \text{Controlável} \\
        \text{Escalabilidade} & \text{Limitada} & \text{Alta}
        \end{array}
        """)
        st.markdown("""
        Onde:
        - $d$: Dimensão dos parâmetros do modelo
        - $N$: Número total de amostras de dados
        - $T$: Número de rodadas de comunicação
        """)
        
        st.markdown("""
        **Benefícios do aprendizado federado:**
        - Preserva privacidade dos padrões de consumo
        - Reduz tráfego de rede (dados permanecem locais)
        - Permite personalização local do modelo
        """)

    with tab3:
        st.title("Aprendizado Federado para Previsão de Demanda Energética")
    
        col1, col2 = st.columns(2)
    
        with col1:
            st.image("images/federated_learning.png", caption="Conceito de Aprendizado Federado")
        
        with col2:
            st.markdown("""        
            O Aprendizado Federado (FL) é um paradigma de aprendizado de máquina onde o modelo é treinado em múltiplos dispositivos descentralizados sem compartilhar os dados locais. Isso oferece:
            
            - **Privacidade de dados**: Os dados nunca saem dos dispositivos locais
            - **Eficiência de comunicação**: Apenas parâmetros do modelo são compartilhados
            - **Treinamento colaborativo**: Múltiplos dispositivos contribuem para um modelo global
            - **Conformidade regulatória**: Ajuda no cumprimento de leis como LGPD e GDPR
            """)

            st.markdown("""        
            O aprendizado federado é especialmente adequado para prever a demanda energética porque:
            
            - Permite análise de dados sensíveis de consumo sem expô-los
            - Possibilita a colaboração entre múltiplos consumidores/medidores
            - Reduz o tráfego de rede ao evitar a transferência de dados brutos
            - Permite treinamento em dispositivos de borda (edge computing)
            - Pode aperceiçoar modelos atuais que utilizam análise centralizada de dados
            
            ## Objetivos do Projeto
            
            1. Implementar um sistema de aprendizado federado usando Flower
            2. Aplicar técnicas avançadas de agregação para otimizar o aprendizado
            3. Integrar com dispositivos Raspberry Pi para coleta de dados em tempo real
            4. Desenvolver modelos de regressão para previsão de demanda energética
            """)

elif secao == "🖥️ Implementação":
    st.title("Implementação de Aprendizado Federado com Flower")
    
    steps = st.tabs(["1. Instalação", "2. Estrutura do Projeto", "3. Servidor", "4. Cliente","5. Modelo/Task", "6. Estratégias de Agregação", "7. Execução", '8. pyproject.toml'])
    
    with steps[0]:
        st.subheader("Instalação do Flower")
        st.code("""
        # Instalação via pip
        pip install flwr
        flwr new
        flwr run -e . # instala as dependências que vem no arquivo pyproject.toml
        flwr run .
        
        """, language="bash")
        
        st.info("No caso de ambientes virtuais para isolar as dependências:")
        st.code("""
        # Criar e ativar ambiente virtual
        python -m venv fl_env
        source fl_env/bin/activate  # Linux/Mac
        fl_env\\Scripts\\activate  # Windows
        """, language="bash")
    
    with steps[1]:
        st.subheader("Estrutura Básica do Projeto")
        st.code("""
        fl_project/
        ├── server.py           # Servidor Flower
        ├── client.py           # Implementação do cliente
        ├── model.py            # Definição do modelo ML
        ├── data_loader.py      # Carregamento e pré-processamento de dados
        ├── utils/
        │   ├── __init__.py
        │   ├── metrics.py      # Funções de avaliação de desempenho
        │   └── visualization.py # Visualização de resultados
        ├── config.py           # Configurações do sistema
        ├── requirements.txt    # Dependências do projeto
        └── run.sh              # Script para iniciar servidor e clientes
        |── pyproject.toml       # Configurações do projeto e dependências
        """, language="text")
    
    with steps[2]:
        st.subheader("Implementação do Servidor")
        st.markdown("""
        O servidor Flower é responsável por coordenar o treinamento, distribuir o modelo global e agregar as atualizações dos clientes.
        """)
        
        st.code('''
            from flwr.common import Context, ndarrays_to_parameters
            from flwr.server import ServerApp, ServerAppComponents, ServerConfig
            from flwr.server.strategy import FedAvg
            from fl_inmetro.task import Net, get_weights

            def server_fn(context: Context):
                # Read from config
                num_rounds = context.run_config["num-server-rounds"]
                fraction_fit = context.run_config["fraction-fit"]

                # Initialize model parameters
                ndarrays = get_weights(Net())
                parameters = ndarrays_to_parameters(ndarrays)

                # Define strategy
                strategy = FedAvg(
                    fraction_fit=fraction_fit,
                    fraction_evaluate=1.0,
                    min_available_clients=2,
                    initial_parameters=parameters,
                )
                config = ServerConfig(num_rounds=num_rounds)

                return ServerAppComponents(strategy=strategy, config=config)

            # Create ServerApp
            app = ServerApp(server_fn=server_fn)
        ''', language="python")
    
    with steps[3]:
        st.subheader("Implementação do Cliente")
        st.markdown("""
        O cliente Flower é implementado nos dispositivos onde os dados estão armazenados. 
        Ele treina o modelo localmente e envia atualizações para o servidor.
        """)
        
        st.code('''
        import torch
        from flwr.client import ClientApp, NumPyClient
        from flwr.common import Context
        from fl_inmetro.task import Net, get_weights, load_data, set_weights, test, train

        # Define Flower Client and client_fn
        class FlowerClient(NumPyClient):
            def __init__(self, net, trainloader, valloader, local_epochs):
                self.net = net
                self.trainloader = trainloader
                self.valloader = valloader
                self.local_epochs = local_epochs
                self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
                self.net.to(self.device)

            def fit(self, parameters, config):
                set_weights(self.net, parameters)
                train_loss = train(
                    self.net,
                    self.trainloader,
                    self.local_epochs,
                    self.device,
                )
                return (
                    get_weights(self.net),
                    len(self.trainloader.dataset),
                    {"train_loss": train_loss},
                )

            def evaluate(self, parameters, config):
                set_weights(self.net, parameters)
                loss, accuracy = test(self.net, self.valloader, self.device)
                return loss, len(self.valloader.dataset), {"accuracy": accuracy}

        def client_fn(context: Context):
            # Load model and data
            net = Net()
            partition_id = context.node_config["partition-id"]
            num_partitions = context.node_config["num-partitions"]
            trainloader, valloader = load_data(partition_id, num_partitions)
            local_epochs = context.run_config["local-epochs"]

            # Return Client instance
            return FlowerClient(net, trainloader, valloader, local_epochs).to_client()

        # Flower ClientApp
        app = ClientApp(
            client_fn,
        )
        ''', language="python")

    with steps[4]:
        st.subheader('Modelo/Tarefas')
        st.code(
        """
        from collections import OrderedDict
        import torch
        import torch.nn as nn
        import torch.nn.functional as F
        from flwr_datasets import FederatedDataset
        from flwr_datasets.partitioner import IidPartitioner
        from torch.utils.data import DataLoader
        from torchvision.transforms import Compose, Normalize, ToTensor

        class Net(nn.Module):
            '''Model (simple CNN adapted from 'PyTorch: A 60 Minute Blitz')'''

            def __init__(self):
                super(Net, self).__init__()
                self.conv1 = nn.Conv2d(3, 6, 5)
                self.pool = nn.MaxPool2d(2, 2)
                self.conv2 = nn.Conv2d(6, 16, 5)
                self.fc1 = nn.Linear(16 * 5 * 5, 120)
                self.fc2 = nn.Linear(120, 84)
                self.fc3 = nn.Linear(84, 10)

            def forward(self, x):
                x = self.pool(F.relu(self.conv1(x)))
                x = self.pool(F.relu(self.conv2(x)))
                x = x.view(-1, 16 * 5 * 5)
                x = F.relu(self.fc1(x))
                x = F.relu(self.fc2(x))
                return self.fc3(x)

        fds = None  # Cache FederatedDataset

        def load_data(partition_id: int, num_partitions: int):
            '''Load partition CIFAR10 data.'''
            # Only initialize `FederatedDataset` once
            global fds
            if fds is None:
                partitioner = IidPartitioner(num_partitions=num_partitions)
                fds = FederatedDataset(
                    dataset='uoft-cs/cifar10',
                    partitioners={'train': partitioner},
                )
            partition = fds.load_partition(partition_id)
            # Divide data on each node: 80% train, 20% test
            partition_train_test = partition.train_test_split(test_size=0.2, seed=42)
            pytorch_transforms = Compose(
                [ToTensor(), Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
            )

        def apply_transforms(batch):
            '''Apply transforms to the partition from FederatedDataset.'''
            batch['img'] = [pytorch_transforms(img) for img in batch['img']]
            return batch

            partition_train_test = partition_train_test.with_transform(apply_transforms)
            trainloader = DataLoader(partition_train_test['train'], batch_size=32, shuffle=True)
            testloader = DataLoader(partition_train_test['test'], batch_size=32)
            return trainloader, testloader

        def train(net, trainloader, epochs, device):
            '''Train the model on the training set.'''
            net.to(device)  # move model to GPU if available
            criterion = torch.nn.CrossEntropyLoss().to(device)
            optimizer = torch.optim.Adam(net.parameters(), lr=0.01)
            net.train()
            running_loss = 0.0
            for _ in range(epochs):
                for batch in trainloader:
                    images = batch['img']
                    labels = batch['label']
                    optimizer.zero_grad()
                    loss = criterion(net(images.to(device)), labels.to(device))
                    loss.backward()
                    optimizer.step()
                    running_loss += loss.item()

            avg_trainloss = running_loss / len(trainloader)
            return avg_trainloss

        def test(net, testloader, device):
            '''Validate the model on the test set.'''
            net.to(device)
            criterion = torch.nn.CrossEntropyLoss()
            correct, loss = 0, 0.0
            with torch.no_grad():
                for batch in testloader:
                    images = batch['img'].to(device)
                    labels = batch['label'].to(device)
                    outputs = net(images)
                    loss += criterion(outputs, labels).item()
                    correct += (torch.max(outputs.data, 1)[1] == labels).sum().item()
            accuracy = correct / len(testloader.dataset)
            loss = loss / len(testloader)
            return loss, accuracy

        def get_weights(net):
            return [val.cpu().numpy() for _, val in net.state_dict().items()]

        def set_weights(net, parameters):
            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)
        """, language="python"
        )
    
    with steps[5]:
        st.subheader("Estratégias de Agregação")
        
        st.markdown("""
        O Flower oferece várias estratégias de agregação para combinar as atualizações dos clientes:
        """)
        
        strategy_tabs = st.tabs(["FedAvg", "FedAdagrad", "FedAdam", "FedYogi", "Personalizada",'Link para mais estratégias'])
        
        with strategy_tabs[0]:
            st.markdown("""
            ### Federated Averaging (FedAvg)
            
            O FedAvg é a estratégia mais comum, que realiza uma média ponderada dos parâmetros do modelo com base no número de amostras em cada cliente.
            """)

            st.image("./images/fedavg.png")
            st.markdown("[McMaham et al. 2023. Communication-Efficient Learning of Deep Networks from Decentralized Data](https://arxiv.org/pdf/1602.05629)")
            
            st.code("""
            # Implementação do FedAvg no servidor
            strategy = fl.server.strategy.FedAvg(
                fraction_fit=1.0,               # Fração de clientes usados em cada round
                min_fit_clients=min_clients,    # Mínimo de clientes para iniciar o treino
                min_available_clients=min_clients,  # Mínimo de clientes necessários
            )
            """, language="python")
        
        with strategy_tabs[1]:
            st.markdown("""
            ### FedAdagrad
            
            O FedAdagrad adapta o algoritmo Adagrad para o cenário federado, ajustando as taxas de aprendizado com base em gradientes anteriores.
            """)

            st.image('./images/FedAdaGrad-Yogi-Adam.png')
            st.markdown("[Reddi et al. DAPTIVE FEDERATED OPTIMIZATION](https://arxiv.org/pdf/2003.00295)")

            st.code("""
            # Implementação do FedAdagrad no servidor
            strategy = fl.server.strategy.FedAdagrad(
                fraction_fit=1.0,
                min_fit_clients=min_clients,
                min_available_clients=min_clients,
                eta=0.1,                       # Taxa de aprendizado do servidor
                eta_l=0.01,                    # Taxa de aprendizado do cliente
            )
            """, language="python")
        
        with strategy_tabs[2]:
            st.markdown("""
            ### FedAdam
            
            O FedAdam adapta o otimizador Adam para o cenário federado, incorporando momentos para melhorar a convergência.
            """)

            st.image('./images/FedAdaGrad-Yogi-Adam.png')
            st.markdown("[Reddi et al. DAPTIVE FEDERATED OPTIMIZATION](https://arxiv.org/pdf/2003.00295)")
            
            st.code("""
            # Implementação do FedAdam no servidor
            strategy = fl.server.strategy.FedAdam(
                fraction_fit=1.0,
                min_fit_clients=min_clients,
                min_available_clients=min_clients,
                eta=0.1,                       # Taxa de aprendizado do servidor
                eta_l=0.01,                    # Taxa de aprendizado do cliente
                beta_1=0.9,                    # Decaimento exponencial para momentos de primeira ordem
                beta_2=0.99,                   # Decaimento exponencial para momentos de segunda ordem
            )
            """, language="python")
        
        with strategy_tabs[3]:
            st.markdown("""
            ### FedYogi
            
            O FedYogi é uma variante do FedAdam que utiliza uma atualização diferente para os momentos de segunda ordem para melhor lidar com dados não IID.
            """)
            
            st.image('./images/FedAdaGrad-Yogi-Adam.png')
            st.markdown("[Reddi et al. DAPTIVE FEDERATED OPTIMIZATION](https://arxiv.org/pdf/2003.00295)")

            st.code("""
            # Implementação do FedYogi no servidor
            strategy = fl.server.strategy.FedYogi(
                fraction_fit=1.0,
                min_fit_clients=min_clients,
                min_available_clients=min_clients,
                eta=0.1,                       # Taxa de aprendizado do servidor
                eta_l=0.01,                    # Taxa de aprendizado do cliente
                beta_1=0.9,                    # Decaimento exponencial para momentos de primeira ordem
                beta_2=0.99,                   # Decaimento exponencial para momentos de segunda ordem
                tau=0.001,                     # Parâmetro de controle para atualização
            )
            """, language="python")
        
        with strategy_tabs[4]:
            st.markdown("""
            ### Estratégia Personalizada
            """)
            
            st.code('''
            # Estratégia personalizada para agregação
            class MyStrategy(fl.server.strategy.FedAvg):
            ''', language="python")
        
        with strategy_tabs[5]:
            st.markdown("""
            ### Link para mais estratégias
            
            Mais estratégias de agregação disponíveis na [documentação oficial](https://flower.dev/docs/strategies.html).
                        
            Link das opções de partição de dados: [Flower Partitioner](https://flower.ai/docs/datasets/ref-api/flwr_datasets.partitioner.html)
            """)
    
    with steps[6]:
        st.subheader("Executando o Sistema")
        
        st.markdown("""
        Para executar o sistema de aprendizado federado, precisa iniciar o servidor e os clientes:
        """)
        
        st.code("""
        # Iniciar o servidor
        python server.py --rounds 10 --min_clients 3 --port 8080
        
        # Em terminais diferentes, iniciar os clientes
        python client.py --partition 0 --num_partitions 3 --server 127.0.0.1:8080
        python client.py --partition 1 --num_partitions 3 --server 127.0.0.1:8080
        python client.py --partition 2 --num_partitions 3 --server 127.0.0.1:8080
        """, language="bash")
        
        st.markdown("""
        Alternativamente, dá para criar um script para automatizar este processo:
        """)
        
        st.code("""
        #!/bin/bash
        # run.sh
        
        # Inicia o servidor em background
        python server.py --rounds 10 --min_clients 3 --port 8080 &
        SERVER_PID=$!
        
        # Espera o servidor iniciar
        sleep 2
        
        # Inicia os clientes
        for i in $(seq 0 2); do
            python client.py --partition $i --num_partitions 3 --server 127.0.0.1:8080 &
            CLIENT_PIDS[$i]=$!
        done
        
        # Espera pelo término do servidor
        wait $SERVER_PID
        
        # Mata os processos dos clientes se ainda estiverem rodando
        for pid in "${CLIENT_PIDS[@]}"; do
            kill -0 $pid 2>/dev/null && kill $pid
        done
        """, language="bash")
    with steps[7]:
        st.subheader("Arquivo pyproject.toml")
        
        st.markdown("""
        O arquivo `pyproject.toml` é usado para gerenciar as dependências do projeto e configurações do ambiente.
        """)
        
        st.code("""
        [build-system]
        requires = ["hatchling"]
        build-backend = "hatchling.build"

        [project]
        name = "fl-inmetro"
        version = "1.0.0"
        description = ""
        license = "Apache-2.0"
        dependencies = [
            "flwr[simulation]>=1.18.0",
            "flwr-datasets[vision]>=0.5.0",
            "torch==2.5.1",
            "torchvision==0.20.1",
        ]

        [tool.hatch.build.targets.wheel]
        packages = ["."]

        [tool.flwr.app]
        publisher = "jwsouza"

        [tool.flwr.app.components]
        serverapp = "fl_inmetro.server_app:app"
        clientapp = "fl_inmetro.client_app:app"

        [tool.flwr.app.config]
        num-server-rounds = 3
        fraction-fit = 0.5
        local-epochs = 1

        [tool.flwr.federations]
        default = "local-simulation"

        [tool.flwr.federations.local-simulation]
        options.num-supernodes = 10

        """, language="toml")

elif secao == "📊 Visualização":
    st.title("Processo de Aprendizado Federado")
    
#    visualization_tabs = st.tabs(["Animação do Processo FL", "Convergência do Modelo", "Desempenho por Cliente", "Comparação de Estratégias"])
    
#    with visualization_tabs[0]:
        
    # Criando um gráfico interativo com Plotly
    fig = go.Figure()
    
    # Nós
    server_pos = [5, 10]
    client_positions = [[2, 5], [5, 5], [8, 5]]
    data_positions = [[2, 0], [5, 0], [8, 0]]
    
    # Adicionando nós
    fig.add_trace(go.Scatter(
        x=[server_pos[0]], 
        y=[server_pos[1]], 
        mode='markers+text',
        marker=dict(symbol='square', size=40, color='red'),
        text=['Servidor'],
        textposition='top center',
        name='Servidor'
    ))
    
    fig.add_trace(go.Scatter(
        x=[pos[0] for pos in client_positions], 
        y=[pos[1] for pos in client_positions], 
        mode='markers+text',
        marker=dict(symbol='circle', size=30, color='green'),
        text=['Cliente 1', 'Cliente 2', 'Cliente 3'],
        textposition='middle right',
        name='Clientes'
    ))
    
    fig.add_trace(go.Scatter(
        x=[pos[0] for pos in data_positions], 
        y=[pos[1] for pos in data_positions], 
        mode='markers+text',
        marker=dict(symbol='diamond', size=20, color='blue'),
        text=['Dados 1', 'Dados 2', 'Dados 3'],
        textposition='bottom center',
        name='Dados'
    ))
    
    # Adicionando linhas de conexão
    for i, client_pos in enumerate(client_positions):
        # Linha do servidor para o cliente (modelo global)
        fig.add_trace(go.Scatter(
            x=[server_pos[0], client_pos[0]], 
            y=[server_pos[1], client_pos[1]],
            mode='lines+text',
            line=dict(width=2, color='red', dash='dash'),
            text=['Modelo Global'],
            textposition='top right',
            showlegend=False
        ))
        
        # Linha do cliente para o servidor (atualizações)
        fig.add_trace(go.Scatter(
            x=[client_pos[0], server_pos[0]], 
            y=[client_pos[1], server_pos[1]],
            mode='lines+text',
            line=dict(width=2, color='green', dash='dot'),
            text=['Atualizações'],
            textposition='bottom left',
            showlegend=False
        ))
        
        # Linha dos dados para o cliente (treino local)
        fig.add_trace(go.Scatter(
            x=[data_positions[i][0], client_pos[0]], 
            y=[data_positions[i][1], client_pos[1]],
            mode='lines+text',
            line=dict(width=2, color='blue'),
            text=['Treino Local'],
            textposition='middle left',
            showlegend=False
        ))
    
    # Layout
    fig.update_layout(
        title='Fluxo de Aprendizado Federado Interativo',
        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
        width=800,
        height=500,
        legend=dict(x=0, y=1),
        hovermode='closest'
    )
    
    st.plotly_chart(fig)

if secao == "📈 Modelos para EVs":

    st.caption("Zhang et al. (2024). Modelos de Consumo de Energia para Veículos Elétricos em Transporte Urbano. Renewable Energy")

    st.markdown("""
    **Objetivo**: Prever consumo energético (CE) de VEs em cenários urbanos:
    """)
    st.latex(r"""
    \min_{\theta} \mathcal{L}(\theta) = \mathbb{E}_{(\mathbf{x},y) \sim \mathcal{P}} [\ell(f_\theta(\mathbf{x}), y)]
    """)

    st.markdown("""
    Onde:
    - $y$: consumo energético observado
    - $f_\theta$: modelo de previsão
    """)

    st.header("Abordagens Tradicionais")
    st.subheader("Modelos de Dinâmica Veicular")
    st.latex(r"""
    F_t = \underbrace{\delta Ma}_{\text{Inércia}} + \underbrace{Mg\sin\alpha}_{\text{Inclinação}} + \underbrace{Mg f \cos\alpha}_{\text{Rolamento}} + \underbrace{\frac{1}{2}\rho C_d A v^2}_{\text{Aerodinâmica}}
    """)
    st.latex(r"""
    P_{\text{total}} = (F_t \cdot v)/\eta_{\text{motor}} + P_{\text{aux}}
    """)
    st.markdown("""
    **Limitações**:
    - Requer 12+ parâmetros específicos (Tabela 1)
    - Não captura efeitos não-lineares em condições urbanas complexas
    """)

    st.subheader("Modelos Estatísticos")
    st.latex(r"""
    \text{CE} = \beta_0 + \sum_{i=1}^k \beta_i X_i + \epsilon \quad \text{(Regressão Linear)}
    """)
    st.latex(r"""
    \text{UEC}(BDR) = a_0 + a_1 \cdot BDR + a_2 \cdot BDR^2 \quad \text{(Degradação de Bateria)}
    """)
    st.markdown("""
    **Problemas**: Pressupõe relações lineares e não considera interações complexas entre variáveis
    """)

    st.subheader("Modelos Principais")
    st.markdown("""
    - **XGBoost/LightGBM**: 
    """)
    st.latex(r"""
    \mathcal{L}^{(t)} = \sum_{i=1}^n \ell(y_i, \hat{y}_i^{(t-1)} + f_t(\mathbf{x}_i)) + \Omega(f_t)
    """)
    st.markdown("""
    - **Random Forest**: Média de $B$ árvores de decisão
    """)

    st.header("Redes Neurais para Alta Precisão")
    st.markdown("""
    **LSTM**:
    """)
    st.latex(r"""
    \begin{aligned}
    i_t &= \sigma(W_{ix} x_t + W_{ih} h_{t-1} + b_i) \\
    c_t &= f_t \odot c_{t-1} + i_t \odot \tanh(W_{cx} x_t + W_{ch} h_{t-1} + b_c) \\
    h_t &= o_t \odot \tanh(c_t)
    \end{aligned}
    """)
    st.markdown("""
    **Transformer**:
    """)
    st.latex(r"""
    \text{Attention}(Q,K,V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V
    """)

    st.subheader("4.2 Desempenho Comparativo")
    st.markdown("""
    | Modelo          | RMSE (kWh) | MAPE (%) | Limitações               |
    |-----------------|------------|----------|--------------------------|
    | Dinâmica Veicular | 6.06       | 14.10    | Parâmetros fixos         |
    | XGBoost         | 3.94       | 9.31     | Menor capacidade não-linear |
    | LSTM            | 3.61       | 8.69     | Custo computacional alto |
    | Transformer     | 2.98       | 7.21     | Dados de treino massivos |
    """)

if secao == "🍓 Integração Raspberry Pi":
    st.markdown("""

    1. **Configurar acesso SSH**  
       - Habilite o SSH no Pi (`raspi-config` → *Interfacing Options* → *SSH*).  
       - Anote o endereço IP do Pi na sua rede.

    2. **Obter o código-fonte**  
       - **Via Git**:  
         ```bash
         git clone https://github.com/SEU_USUARIO/SEU_PROJETO.git
         cd SEU_PROJETO
         ```  
       - **Via SCP/RSYNC** (se não usar Git):  
         ```bash
         scp -r caminho/local/SEU_PROJETO pi@IP_DO_PI:~/SEU_PROJETO
         ```

    3. **Instalar dependências no Pi**  
       ```bash
       python3 -m venv venv
       source venv/bin/activate
       pip install -r requirements.txt
       ```

    4. **Copiar arquivos estáticos**  
       - Certifique-se de que a pasta `images/` foi clonada/copied e que os paths relativos estejam corretos.

    5. **Configurar serviço de inicialização**  
       - Crie um serviço systemd em `/etc/systemd/system/fl-client.service` apontando para o comando de execução no seu virtualenv.
       - Habilite e inicie:
         ```bash
         sudo systemctl enable fl-client
         sudo systemctl start fl-client
         ```

    6. **Testar localmente**  
       ```bash
       source venv/bin/activate
       python client_pi.py
       ```

    7. **Automatizar atualizações**  
       - No CI/CD, adicione um passo para:  
         ```bash
         ssh pi@IP_DO_PI \
           'cd ~/SEU_PROJETO && git pull && source venv/bin/activate && pip install -r requirements.txt && systemctl restart fl-client'
         ```
    """, unsafe_allow_html=False)

if secao == "📚 Artigos":

    st.markdown(
        """
        ### Referências
        - FedAVG

        [McMaham et al. 2023. Communication-Efficient Learning of Deep Networks from Decentralized Data](https://arxiv.org/pdf/1602.05629)
        
        - ADAGRAD, ADAM, YOGI

        [Reddi et al. DAPTIVE FEDERATED OPTIMIZATION](https://arxiv.org/pdf/2003.00295)

        - Privacdiade e Segurança

        [Bonawitz et al. Practical Secure Aggregation for Privacy-Preserving Machine Learning](https://arxiv.org/pdf/1611.04482)


        [Abadi et al. Deep Learning with Differential Privacy](https://arxiv.org/pdf/1607.00133)
        """
    )