Arquivo de Python - Página 7 de 31

Filtro de Kalman

16/07/202618/06/2026 Por antonino

O que é o filtro de Kalman?

O filtro de Kalman é um algoritmo de estimação recursiva que combina previsões e medições ruidosas. Ele foi desenvolvido por Rudolf E. Kálmán na década de 1960 para sistemas lineares gaussianos. O filtro mantém uma estimativa do estado oculto e sua incerteza (covariância). A cada passo, ele faz uma previsão (modelo dinâmico) e uma correção (medição). A correção é ponderada pela confiança em cada fonte: o ganho de Kalman. Esse ganho minimiza o erro quadrático médio da estimativa. O filtro é ótimo para sistemas lineares com ruídos gaussianos brancos. Ele é amplamente usado em navegação, controle, visão computacional e finanças. Sua implementação é eficiente, exigindo apenas operações matriciais.

Características fundamentais

O filtro de Kalman possui três características principais que o definem. Primeiro, ele é recursivo: não precisa de todo o histórico, apenas do estado atual. Segundo, ele fornece uma estimativa de incerteza (matriz de covariância) junto com o estado. Terceiro, ele é ótimo no sentido de mínimos quadrados para sistemas lineares. Ele também pode lidar com medições de diferentes frequências ou com dados faltantes. A predição usa um modelo de transição de estado (matriz A) e controle (B). A correção usa um modelo de observação (matriz H) que relaciona estado e medição.

Vantagens e aplicações típicas

A principal vantagem é a capacidade de fundir dados de múltiplos sensores ruidosos. Ele é usado em GPS, rastreamento de alvos, robótica e economia. Também é aplicado em filtragem de sinais e previsão de séries temporais. Contudo, ele falha em sistemas não-lineares; para esses, usa-se o filtro estendido (EKF) ou unscented (UKF).

O filtro de Kalman é um caso especial de inferência bayesiana em redes gaussianas dinâmicas. A predição é o passo de “propagação” da crença usando o modelo dinâmico. A correção é o passo de “atualização” usando a verossimilhança da medição. O ganho de Kalman K = P_pred * H^T * (H * P_pred * H^T + R)^(-1). Ele equilibra a incerteza da previsão (P_pred) e o ruído da medição (R). Se o ruído de medição é alto, K é pequeno, confiando mais na previsão. Se a previsão é incerta, K é grande, confiando mais na medição. O filtro converge rapidamente e é estável para sistemas detectáveis. A matriz de covariância P evolui e diminui com o tempo, convergindo para um valor estacionário. O filtro também pode estimar parâmetros desconhecidos (filtro de Kalman estendido dual). Ele é a base de sistemas de navegação inercial (INS/GPS) em aviões e carros autônomos. No rastreamento de objetos, ele prevê a posição futura e corrige com detecções visuais. O filtro de Kalman é frequentemente o primeiro algoritmo ensinado em cursos de estimação. Assim, ele é uma ferramenta essencial para engenheiros e cientistas de dados.

Um exemplo clássico é rastrear a posição de um carro em movimento retilíneo uniforme. O estado é [posição, velocidade]. A medição é a posição com ruído. O modelo de transição é posição += velocidade*dt, velocidade constante. O filtro estima a posição suavizada e a velocidade mesmo com medições ruidosas.

Enunciado do exemplo clássico

Implemente o filtro de Kalman para rastrear um objeto em 1D com movimento uniforme. Estado: [posição (m), velocidade (m/s)]. dt = 0.1 s. Modelo dinâmico: posição = posição + velocidade*dt + ruído de processo (q=0.5). Medição: posição observada com ruído gaussiano (r=2.0). Gere 50 medições sintéticas a partir de uma trajetória real (posição inicial 0, vel=3 m/s). Execute o filtro e plote a posição real, as medições e a estimativa filtrada.

import numpy as np  
import matplotlib.pyplot as plt  

# Parâmetros do sistema  
dt = 0.1  
q = 0.5    # variância do ruído de processo (aceleração aleatória)  
r = 2.0    # variância do ruído de medição  

# Matrizes do filtro de Kalman  
A = np.array([[1, dt],  
              [0, 1]])   # transição de estado  
H = np.array([[1, 0]])   # observação (só posição)  
Q = np.array([[q * dt**3 / 3, q * dt**2 / 2],  
              [q * dt**2 / 2, q * dt]])  # covariância do ruído de processo  
R = np.array([[r]])       # covariância do ruído de medição  

# Estado inicial real  
x0_real = 0.0  
v_real = 3.0  
n_passos = 50  
tempos = np.arange(n_passos) * dt  

# Gerar trajetória real e medições ruidosas  
np.random.seed(42)  
estado_real = np.zeros((n_passos, 2))  
estado_real[0] = [x0_real, v_real]  
for k in range(1, n_passos):  
    # Processo com ruído (aceleração aleatória)  
    ruido_processo = np.array([[0.5 * q * dt**2], [q * dt]]) * np.random.randn()  
    estado_real[k] = A @ estado_real[k-1] + ruido_processo.ravel()  

# Medições (posição com ruído)  
medicoes = np.zeros(n_passos)  
for k in range(n_passos):  
    medicoes[k] = H @ estado_real[k] + np.random.normal(0, np.sqrt(r))  

# Inicialização do filtro  
x_hat = np.array([[0.0], [0.0]])   # estimativa inicial  
P = np.array([[10, 0], [0, 10]])  # incerteza inicial alta  

# Armazenar estimativas  
estimativas = np.zeros((n_passos, 2))  
covariancias = np.zeros((n_passos, 2, 2))  

for k in range(n_passos):  
    # Passo de predição  
    x_hat_pred = A @ x_hat  
    P_pred = A @ P @ A.T + Q  

    # Passo de correção (se houver medição)  
    # Ganho de Kalman  
    K = P_pred @ H.T @ np.linalg.inv(H @ P_pred @ H.T + R)  
    # Atualizar com a medição  
    z = medicoes[k]  
    y = z - H @ x_hat_pred   # inovação  
    x_hat = x_hat_pred + K @ y  
    P = (np.eye(2) - K @ H) @ P_pred  

    estimativas[k] = x_hat.ravel()  
    covariancias[k] = P  

# Extrair posição e velocidade estimadas  
pos_est = estimativas[:, 0]  
vel_est = estimativas[:, 1]  
pos_real = estado_real[:, 0]  
vel_real = estado_real[:, 1]  

# Calcular erro RMS  
erro_pos = np.sqrt(np.mean((pos_est - pos_real)**2))  
print(f"Erro RMS da posição: {erro_pos:.3f} m")  

# Gráficos  
plt.figure(figsize=(12, 5))  

plt.subplot(1, 2, 1)  
plt.plot(tempos, pos_real, 'g-', linewidth=2, label='Posição real')  
plt.scatter(tempos, medicoes, color='red', s=20, alpha=0.6, label='Medições ruidosas')  
plt.plot(tempos, pos_est, 'b-', linewidth=2, label='Estimativa filtrada (posição)')  
# Incerteza (2 desvios)  
desvio = np.sqrt(covariancias[:, 0, 0])  
plt.fill_between(tempos, pos_est - 2*desvio, pos_est + 2*desvio,  
                 color='blue', alpha=0.2, label='Intervalo 95%')  
plt.xlabel('Tempo (s)')  
plt.ylabel('Posição (m)')  
plt.title('Filtro de Kalman - Rastreamento de Posição')  
plt.legend()  
plt.grid(True)  

plt.subplot(1, 2, 2)  
plt.plot(tempos, vel_real, 'g--', linewidth=2, label='Velocidade real')  
plt.plot(tempos, vel_est, 'b-', linewidth=2, label='Velocidade estimada')  
desvio_vel = np.sqrt(covariancias[:, 1, 1])  
plt.fill_between(tempos, vel_est - 2*desvio_vel, vel_est + 2*desvio_vel,  
                 color='blue', alpha=0.2, label='Intervalo 95%')  
plt.xlabel('Tempo (s)')  
plt.ylabel('Velocidade (m/s)')  
plt.title('Estimativa da Velocidade')  
plt.legend()  
plt.grid(True)  

plt.tight_layout()  
plt.show()

100

101

102

import numpy as np

import matplotlib.pyplot as plt

# Parâmetros do sistema

dt = 0.1

q = 0.5 # variância do ruído de processo (aceleração aleatória)

r = 2.0 # variância do ruído de medição

# Matrizes do filtro de Kalman

A = np.array([[1, dt],

[0, 1]]) # transição de estado

H = np.array([[1, 0]]) # observação (só posição)

Q = np.array([[q * dt**3 / 3, q * dt**2 / 2],

[q * dt**2 / 2, q * dt]]) # covariância do ruído de processo

R = np.array([[r]]) # covariância do ruído de medição

# Estado inicial real

x0_real = 0.0

v_real = 3.0

n_passos = 50

tempos = np.arange(n_passos) * dt

# Gerar trajetória real e medições ruidosas

np.random.seed(42)

estado_real = np.zeros((n_passos, 2))

estado_real[0] = [x0_real, v_real]

for k in range(1, n_passos):

# Processo com ruído (aceleração aleatória)

ruido_processo = np.array([[0.5 * q * dt**2], [q * dt]]) * np.random.randn()

estado_real[k] = A @ estado_real[k-1] + ruido_processo.ravel()

# Medições (posição com ruído)

medicoes = np.zeros(n_passos)

for k in range(n_passos):

medicoes[k] = H @ estado_real[k] + np.random.normal(0, np.sqrt(r))

# Inicialização do filtro

x_hat = np.array([[0.0], [0.0]]) # estimativa inicial

P = np.array([[10, 0], [0, 10]]) # incerteza inicial alta

# Armazenar estimativas

estimativas = np.zeros((n_passos, 2))

covariancias = np.zeros((n_passos, 2, 2))

for k in range(n_passos):

# Passo de predição

x_hat_pred = A @ x_hat

P_pred = A @ P @ A.T + Q

# Passo de correção (se houver medição)

# Ganho de Kalman

K = P_pred @ H.T @ np.linalg.inv(H @ P_pred @ H.T + R)

# Atualizar com a medição

z = medicoes[k]

y = z - H @ x_hat_pred # inovação

x_hat = x_hat_pred + K @ y

P = (np.eye(2) - K @ H) @ P_pred

estimativas[k] = x_hat.ravel()

covariancias[k] = P

# Extrair posição e velocidade estimadas

pos_est = estimativas[:, 0]

vel_est = estimativas[:, 1]

pos_real = estado_real[:, 0]

vel_real = estado_real[:, 1]

# Calcular erro RMS

erro_pos = np.sqrt(np.mean((pos_est - pos_real)**2))

print(f"Erro RMS da posição: {erro_pos:.3f} m")

# Gráficos

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)

plt.plot(tempos, pos_real, 'g-', linewidth=2, label='Posição real')

plt.scatter(tempos, medicoes, color='red', s=20, alpha=0.6, label='Medições ruidosas')

plt.plot(tempos, pos_est, 'b-', linewidth=2, label='Estimativa filtrada (posição)')

# Incerteza (2 desvios)

desvio = np.sqrt(covariancias[:, 0, 0])

plt.fill_between(tempos, pos_est - 2*desvio, pos_est + 2*desvio,

color='blue', alpha=0.2, label='Intervalo 95%')

plt.xlabel('Tempo (s)')

plt.ylabel('Posição (m)')

plt.title('Filtro de Kalman - Rastreamento de Posição')

plt.legend()

plt.grid(True)

plt.subplot(1, 2, 2)

plt.plot(tempos, vel_real, 'g--', linewidth=2, label='Velocidade real')

plt.plot(tempos, vel_est, 'b-', linewidth=2, label='Velocidade estimada')

desvio_vel = np.sqrt(covariancias[:, 1, 1])

plt.fill_between(tempos, vel_est - 2*desvio_vel, vel_est + 2*desvio_vel,

color='blue', alpha=0.2, label='Intervalo 95%')

plt.xlabel('Tempo (s)')

plt.ylabel('Velocidade (m/s)')

plt.title('Estimativa da Velocidade')

plt.legend()

plt.grid(True)

plt.tight_layout()

plt.show()

Este código implementa o filtro de Kalman para rastreamento 1D. As medições ruidosas são suavizadas pela estimativa recursiva. O intervalo de confiança (2σ) mostra a incerteza da estimativa. A velocidade é estimada indiretamente, mesmo sem ser medida diretamente. Para iniciantes, este exemplo demonstra o poder da fusão de dados. O filtro de Kalman é, portanto, uma ferramenta fundamental em engenharia de controle.

Redes Bayesianas para Classificação

16/07/202618/06/2026 Por antonino

O que são redes bayesianas para classificação?

Redes bayesianas para classificação são modelos gráficos probabilísticos que predizem uma variável alvo discreta. Elas representam dependências entre atributos e a classe usando um grafo acíclico direcionado. Cada nó é uma variável, e arestas indicam influência condicional entre elas. A classe geralmente é um nó especial, frequentemente com pais ou filhos. A classificação é feita calculando P(classe | evidência) via inferência na rede. Diferentemente do Naive Bayes, elas permitem dependências entre atributos. Isso aumenta a acurácia quando atributos são correlacionados. Além disso, redes bayesianas podem lidar com dados faltantes e variáveis latentes. Elas são interpretáveis: cada aresta tem um significado causal ou associativo. Portanto, são usadas em diagnósticos, sistemas especialistas e bioinformática.

Características fundamentais

Redes para classificação possuem três características principais que as definem. Primeiro, a estrutura pode ser aprendida a partir dos dados (aprendizado de estrutura). Segundo, a inferência pode ser exata (para redes pequenas) ou aproximada (MCMC). Terceiro, elas fornecem distribuições de probabilidade sobre as classes, não apenas rótulos. Isso é essencial para decisões com custos assimétricos. A classe pode ser um nó raiz (causa) ou um nó folha (efeito). Quando a classe é raiz, o modelo é gerativo (ex.: Naive Bayes). Quando é folha, é discriminativo (ex.: redes de regressão logística bayesiana).

Vantagens e aplicações típicas

A principal vantagem é a flexibilidade para modelar relações complexas entre atributos. Elas são usadas em classificação de textos, imagens e sinais médicos. Também são aplicadas em sistemas de recomendação e detecção de intrusão. Contudo, o aprendizado de estrutura é computacionalmente caro.

O classificador TAN (Tree-Augmented Naive Bayes) é um exemplo prático. Ele adiciona arestas entre atributos para capturar as correlações mais fortes. A estrutura é aprendida usando árvore de máxima extensão ponderada por informação mútua. Outra abordagem é usar redes bayesianas completas com restrição de treewidth. Isso permite inferência exata com complexidade controlada. Na classificação, a variável alvo pode ter múltiplos estados (ex.: doença, estágio). As redes bayesianas também podem integrar conhecimento de especialistas via estrutura manual. Isso é valioso quando os dados são escassos ou ruidosos. A predição é feita por propagação de evidências para o nó classe. Algoritmos como eliminação de variáveis ou amostragem são usados. A saída probabilística permite calibrar a confiança da classificação. Por exemplo, pode-se rejeitar amostras com baixa probabilidade máxima. Redes bayesianas também suportam aprendizado incremental com novos dados. Assim, elas são ferramentas poderosas para classificação robusta e interpretável.

Um exemplo clássico é a classificação de risco de crédito com variáveis: renda, idade, histórico, e empréstimo (classe). A rede modela que renda e idade influenciam histórico, e histórico influencia o risco. Dadas as evidências, a rede calcula P(risco | dados) para decisão de aprovação.

Enunciado do exemplo clássico

Implemente uma rede bayesiana para classificar se um paciente tem gripe (G) ou resfriado (R) com base em: Febre (F), Tosse (T) e Dor de Cabeça (D). Todas binárias. Relações: G e R influenciam F, T e D de forma independente (Naive Bayes com duas classes). Defina CPTs manualmente. Dados de treino: 50 pacientes com rótulos. Calcule a acurácia em 20 novos pacientes (gerados sinteticamente). Plote a estrutura da rede e a matriz de confusão.

import numpy as np  
import matplotlib.pyplot as plt  
import networkx as nx  
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay  

# Definição da rede (Naive Bayes com duas classes)  
# Classes: 0 = Gripe, 1 = Resfriado (priores)  
P_G = 0.4  
P_R = 0.6  

# Probabilidades condicionais: P(Sintoma | Classe)  
# Febre (F)  
P_F_dado_G = {0: 0.1, 1: 0.9}  # P(F=0|G), P(F=1|G)  
P_F_dado_R = {0: 0.3, 1: 0.7}  

# Tosse (T)  
P_T_dado_G = {0: 0.2, 1: 0.8}  
P_T_dado_R = {0: 0.5, 1: 0.5}  

# Dor de Cabeça (D)  
P_D_dado_G = {0: 0.3, 1: 0.7}  
P_D_dado_R = {0: 0.4, 1: 0.6}  

# Função para gerar dados sintéticos  
def gerar_paciente(classe):  
    if classe == 0:  # Gripe  
        F = 1 if np.random.random() < P_F_dado_G[1] else 0  
        T = 1 if np.random.random() < P_T_dado_G[1] else 0  
        D = 1 if np.random.random() < P_D_dado_G[1] else 0  
    else:  # Resfriado  
        F = 1 if np.random.random() < P_F_dado_R[1] else 0  
        T = 1 if np.random.random() < P_T_dado_R[1] else 0  
        D = 1 if np.random.random() < P_D_dado_R[1] else 0  
    return np.array([F, T, D]), classe  

# Gerar treino (50) e teste (20)  
np.random.seed(123)  
n_treino = 50  
n_teste = 20  
dados_treino = []  
rotulos_treino = []  
for _ in range(n_treino):  
    classe = 0 if np.random.random() < P_G else 1  
    x, y = gerar_paciente(classe)  
    dados_treino.append(x)  
    rotulos_treino.append(y)  
dados_treino = np.array(dados_treino)  
rotulos_treino = np.array(rotulos_treino)  

dados_teste = []  
rotulos_teste = []  
for _ in range(n_teste):  
    classe = 0 if np.random.random() < P_G else 1  
    x, y = gerar_paciente(classe)  
    dados_teste.append(x)  
    rotulos_teste.append(y)  
dados_teste = np.array(dados_teste)  
rotulos_teste = np.array(rotulos_teste)  

# Classificador Naive Bayes (aprendendo as probabilidades dos dados de treino)  
# Estimar priores  
priores = np.array([np.mean(rotulos_treino == 0), np.mean(rotulos_treino == 1)])  

# Estimar P(sintoma | classe) para cada atributo  
# Atributos: 0=F, 1=T, 2=D  
probs = []  
for classe in (0,1):  
    dados_classe = dados_treino[rotulos_treino == classe]  
    probs_classe = []  
    for atributo in range(3):  
        # P(atributo=1 | classe)  
        prob1 = np.mean(dados_classe[:, atributo] == 1)  
        probs_classe.append({0: 1-prob1, 1: prob1})  
    probs.append(probs_classe)  
# probs[classe][atributo][valor]  

def classificar(sintomas):  
    # sintomas: array [F, T, D]  
    posteriores = []  
    for classe in (0,1):  
        log_prob = np.log(priores[classe])  
        for atr, valor in enumerate(sintomas):  
            # Suavização para evitar log(0)  
            p = probs[classe][atr][valor]  
            if p == 0:  
                p = 1e-6  
            log_prob += np.log(p)  
        posteriores.append(log_prob)  
    return 0 if posteriores[0] > posteriores[1] else 1  

# Classificar teste  
predicoes = [classificar(dados_teste[i]) for i in range(n_teste)]  
acuracia = np.mean(predicoes == rotulos_teste)  
print(f"Acurácia no teste: {acuracia:.3f}")  

# Matriz de confusão  
cm = confusion_matrix(rotulos_teste, predicoes)  

# Plotar estrutura da rede  
G = nx.DiGraph()  
G.add_edges_from([('Classe', 'Febre'), ('Classe', 'Tosse'), ('Classe', 'Dor_Cabeca')])  
pos = {'Classe': (1, 1), 'Febre': (0, 0), 'Tosse': (1, 0), 'Dor_Cabeca': (2, 0)}  

plt.figure(figsize=(12, 5))  

plt.subplot(1, 2, 1)  
nx.draw(G, pos, with_labels=True, node_color='lightgreen',  
        node_size=2500, font_size=10, font_weight='bold',  
        arrowsize=20, edge_color='gray', width=2)  
plt.title('Rede Bayesiana para Classificação\n(Gripe vs Resfriado)')  

plt.subplot(1, 2, 2)  
ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Gripe', 'Resfriado']).plot(ax=plt.gca(), cmap='Blues')  
plt.title(f'Matriz de Confusão (Acurácia = {acuracia:.3f})')  

plt.tight_layout()  
plt.show()  

# Exemplo de classificação de um novo paciente  
novo = np.array([1, 0, 1])  # Febre=sim, Tosse=não, Dor=sim  
classe_pred = classificar(novo)  
print(f"\nNovo paciente (Febre=1, Tosse=0, Dor=1) -> {['Gripe','Resfriado'][classe_pred]}")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

import numpy as np

import matplotlib.pyplot as plt

import networkx as nx

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

# Definição da rede (Naive Bayes com duas classes)

# Classes: 0 = Gripe, 1 = Resfriado (priores)

P_G = 0.4

P_R = 0.6

# Probabilidades condicionais: P(Sintoma | Classe)

# Febre (F)

P_F_dado_G = {0: 0.1, 1: 0.9} # P(F=0|G), P(F=1|G)

P_F_dado_R = {0: 0.3, 1: 0.7}

# Tosse (T)

P_T_dado_G = {0: 0.2, 1: 0.8}

P_T_dado_R = {0: 0.5, 1: 0.5}

# Dor de Cabeça (D)

P_D_dado_G = {0: 0.3, 1: 0.7}

P_D_dado_R = {0: 0.4, 1: 0.6}

# Função para gerar dados sintéticos

def gerar_paciente(classe):

if classe == 0: # Gripe

F = 1 if np.random.random() < P_F_dado_G[1] else 0

T = 1 if np.random.random() < P_T_dado_G[1] else 0

D = 1 if np.random.random() < P_D_dado_G[1] else 0

else: # Resfriado

F = 1 if np.random.random() < P_F_dado_R[1] else 0

T = 1 if np.random.random() < P_T_dado_R[1] else 0

D = 1 if np.random.random() < P_D_dado_R[1] else 0

return np.array([F, T, D]), classe

# Gerar treino (50) e teste (20)

np.random.seed(123)

n_treino = 50

n_teste = 20

dados_treino = []

rotulos_treino = []

for _ in range(n_treino):

classe = 0 if np.random.random() < P_G else 1

x, y = gerar_paciente(classe)

dados_treino.append(x)

rotulos_treino.append(y)

dados_treino = np.array(dados_treino)

rotulos_treino = np.array(rotulos_treino)

dados_teste = []

rotulos_teste = []

for _ in range(n_teste):

classe = 0 if np.random.random() < P_G else 1

x, y = gerar_paciente(classe)

dados_teste.append(x)

rotulos_teste.append(y)

dados_teste = np.array(dados_teste)

rotulos_teste = np.array(rotulos_teste)

# Classificador Naive Bayes (aprendendo as probabilidades dos dados de treino)

# Estimar priores

priores = np.array([np.mean(rotulos_treino == 0), np.mean(rotulos_treino == 1)])

# Estimar P(sintoma | classe) para cada atributo

# Atributos: 0=F, 1=T, 2=D

probs = []

for classe in (0,1):

dados_classe = dados_treino[rotulos_treino == classe]

probs_classe = []

for atributo in range(3):

# P(atributo=1 | classe)

prob1 = np.mean(dados_classe[:, atributo] == 1)

probs_classe.append({0: 1-prob1, 1: prob1})

probs.append(probs_classe)

# probs[classe][atributo][valor]

def classificar(sintomas):

# sintomas: array [F, T, D]

posteriores = []

for classe in (0,1):

log_prob = np.log(priores[classe])

for atr, valor in enumerate(sintomas):

# Suavização para evitar log(0)

p = probs[classe][atr][valor]

if p == 0:

p = 1e-6

log_prob += np.log(p)

posteriores.append(log_prob)

return 0 if posteriores[0] > posteriores[1] else 1

# Classificar teste

predicoes = [classificar(dados_teste[i]) for i in range(n_teste)]

acuracia = np.mean(predicoes == rotulos_teste)

print(f"Acurácia no teste: {acuracia:.3f}")

# Matriz de confusão

cm = confusion_matrix(rotulos_teste, predicoes)

# Plotar estrutura da rede

G = nx.DiGraph()

G.add_edges_from([('Classe', 'Febre'), ('Classe', 'Tosse'), ('Classe', 'Dor_Cabeca')])

pos = {'Classe': (1, 1), 'Febre': (0, 0), 'Tosse': (1, 0), 'Dor_Cabeca': (2, 0)}

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)

nx.draw(G, pos, with_labels=True, node_color='lightgreen',

node_size=2500, font_size=10, font_weight='bold',

arrowsize=20, edge_color='gray', width=2)

plt.title('Rede Bayesiana para Classificação\n(Gripe vs Resfriado)')

plt.subplot(1, 2, 2)

ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Gripe', 'Resfriado']).plot(ax=plt.gca(), cmap='Blues')

plt.title(f'Matriz de Confusão (Acurácia = {acuracia:.3f})')

plt.tight_layout()

plt.show()

# Exemplo de classificação de um novo paciente

novo = np.array([1, 0, 1]) # Febre=sim, Tosse=não, Dor=sim

classe_pred = classificar(novo)

print(f"\nNovo paciente (Febre=1, Tosse=0, Dor=1) -> {['Gripe','Resfriado'][classe_pred]}")

Este código implementa uma rede Naive Bayes para classificação com duas classes. A estrutura mostra a classe como nó raiz influenciando todos os sintomas. A matriz de confusão revela o desempenho do modelo nos dados de teste. O modelo estima probabilidades diretamente dos dados de treino. Para iniciantes, este exemplo demonstra como redes bayesianas resolvem classificação. Redes bayesianas para classificação são, portanto, práticas e interpretáveis.