Arquivo de Python - Página 11 de 31

Redes Bayesianas com Variaveis Continuas

16/07/202618/06/2026 Por antonino

O que são redes bayesianas com variáveis contínuas?

Redes bayesianas com variáveis contínuas modelam relações probabilísticas entre variáveis numéricas reais. Cada nó representa uma variável que pode assumir qualquer valor em um intervalo. Diferentemente das discretas, as distribuições condicionais são funções densidade de probabilidade (PDFs). A forma mais comum é a distribuição normal (gaussiana) para cada nó. Nesse caso, a rede é chamada de rede bayesiana gaussiana (GBN). Cada nó tem uma média que é combinação linear dos pais e uma variância fixa. A distribuição conjunta é uma normal multivariada com estrutura de covariância esparsa. Isso permite inferência eficiente por álgebra linear, sem enumeração de casos. Portanto, redes contínuas são ideais para problemas de engenharia e finanças.

Características fundamentais

Essas redes possuem três características principais que as distinguem. Primeiro, as CPTs são substituídas por equações lineares com coeficientes de regressão. Segundo, a inferência exata é feita por eliminação gaussiana, que é polinomial. Terceiro, a aprendizagem de parâmetros usa estimativa de máxima verossimilhança ou bayesiana. A estrutura pode ser aprendida com algoritmos de busca usando critérios como BIC. Além disso, redes contínuas suportam variáveis latentes (não observadas) com integração analítica. A suposição de normalidade é forte, mas muitas vezes razoável na prática. Transformações como log ou Box-Cox podem tornar os dados mais gaussianos.

Vantagens e aplicações típicas

A principal vantagem é a eficiência computacional para redes de grande porte. Elas são usadas em controle de processos, previsão de séries temporais e genética. Também são aplicadas em sistemas de recomendação baseados em notas contínuas. Outra vantagem é a facilidade de incorporar relações lineares entre variáveis. Contudo, a linearidade pode ser uma limitação para fenômenos não-lineares. Para esses casos, usa-se redes com misturas de gaussianas ou modelos não-paramétricos.

Redes bayesianas contínuas são amplamente usadas em modelos de equações estruturais. Elas permitem testar hipóteses causais com dados observacionais. A inferência por eliminação de variáveis contínuas usa operações de marginalização gaussiana. Isso é equivalente a calcular distribuições condicionais em normais multivariadas. Uma propriedade importante é que a distribuição conjunta é completamente especificada pela média e precisão. A precisão é a inversa da matriz de covariância, que é esparsa (estrutura da rede). Essa esparsidade reduz custo computacional de O(n³) para O(n * grau²). Aprendizado de estrutura em redes contínuas usa testes de correlação parcial. Testes de independência condicional verificam se a correlação entre duas variáveis é zero dado os pais. Algoritmos como PC (Peter-Clark) constroem o grafo a partir desses testes. Redes contínuas também podem ser dinâmicas (DBNs contínuas) para séries temporais. Nesse caso, usa-se modelos autorregressivos vetoriais com estrutura esparsa. Elas são usadas em economia para prever taxas de juros e inflação. Assim, redes contínuas são uma ferramenta poderosa para dados numéricos.

Um exemplo clássico é a rede que relaciona temperatura (T), pressão (P) e volume (V) de um gás. T e P influenciam V, mas T e P são independentes a priori. A relação é aproximadamente linear (lei dos gases ideais) com ruído gaussiano. A rede permite inferir P dado T e V observados, ou V dado T e P.

Enunciado do exemplo clássico

Implemente uma rede bayesiana gaussiana para o sistema: Variáveis: Temperatura (T ~ N(20, 4)), Pressão (P ~ N(101, 9)), e Volume (V = 0.5*T – 0.3*P + erro, erro ~ N(0, 1)). As relações são: T e P são independentes; V depende de T e P linearmente. Construa a matriz de covariância conjunta e calcule P(V | T=25) e P(P | V=10, T=22). Plote a estrutura da rede e as distribuições condicionais resultantes.

import numpy as np  
import matplotlib.pyplot as plt  
import networkx as nx  
from scipy.stats import multivariate_normal  

# Definir a rede gaussiana  
# Variáveis: T (temperatura), P (pressão), V (volume)  
# T e P são independentes com médias e variâncias dadas  
mu_T = 20.0  
var_T = 4.0  
mu_P = 101.0  
var_P = 9.0  

# V = 0.5*T - 0.3*P + erro, erro ~ N(0,1)  
coef_T = 0.5  
coef_P = -0.3  
var_erro = 1.0  

# Construir média conjunta (ordem: T, P, V)  
mu = np.array([mu_T, mu_P, 0.0])  # média de V será calculada  
mu_V = coef_T * mu_T + coef_P * mu_P  
mu[2] = mu_V  

# Construir matriz de covariância conjunta  
# Cov(T,P)=0 (independentes)  
cov = np.zeros((3,3))  
cov[0,0] = var_T  
cov[1,1] = var_P  
# V = coef_T*T + coef_P*P + erro  
# Cov(V,T) = coef_T * Var(T) + coef_P * Cov(P,T) = coef_T * var_T  
cov[2,0] = coef_T * var_T  
cov[0,2] = cov[2,0]  
# Cov(V,P) = coef_T * Cov(T,P) + coef_P * Var(P) = coef_P * var_P  
cov[2,1] = coef_P * var_P  
cov[1,2] = cov[2,1]  
# Var(V) = coef_T^2 * Var(T) + coef_P^2 * Var(P) + Var(erro)  
cov[2,2] = coef_T**2 * var_T + coef_P**2 * var_P + var_erro  

# Inferência condicional por fórmula para normais multivariadas  
def condicional(mu, cov, idx_obs, valores_obs, idx_pred):  
    # idx_obs: lista de índices observados  
    # valores_obs: valores correspondentes  
    # idx_pred: índice da variável a prever  
    # Retorna (média, variância) condicional  
    mu_obs = mu[idx_obs]  
    mu_pred = mu[idx_pred]  
    cov_obs = cov[np.ix_(idx_obs, idx_obs)]  
    cov_pred_obs = cov[idx_pred, idx_obs]  
    # Média condicional  
    inv_cov_obs = np.linalg.inv(cov_obs)  
    mu_cond = mu_pred + cov_pred_obs @ inv_cov_obs @ (valores_obs - mu_obs)  
    var_cond = cov[idx_pred, idx_pred] - cov_pred_obs @ inv_cov_obs @ cov_pred_obs.T  
    return mu_cond, var_cond  

# 1. P(V | T=25)  
mu_V_dado_T, var_V_dado_T = condicional(mu, cov, [0], [25], 2)  
print(f"P(V | T=25) -> média = {mu_V_dado_T:.4f}, variância = {var_V_dado_T:.4f}")  

# 2. P(P | V=10, T=22)  
mu_P_dado_VT, var_P_dado_VT = condicional(mu, cov, [2,0], [10,22], 1)  
print(f"P(P | V=10, T=22) -> média = {mu_P_dado_VT:.4f}, variância = {var_P_dado_VT:.4f}")  

# Plotar estrutura da rede  
G = nx.DiGraph()  
G.add_edges_from([('T', 'V'), ('P', 'V')])  
pos = {'T': (0, 1), 'P': (0, 0), 'V': (1.5, 0.5)}  

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

plt.subplot(1, 2, 1)  
nx.draw(G, pos, with_labels=True, node_color='lightcoral',  
        node_size=2500, font_size=12, font_weight='bold',  
        arrowsize=20, edge_color='gray', width=2)  
plt.title('Rede Gaussiana - T, P, V')  

plt.subplot(1, 2, 2)  
# Plotar distribuições condicionais  
x = np.linspace(mu_V_dado_T - 3*np.sqrt(var_V_dado_T),  
                mu_V_dado_T + 3*np.sqrt(var_V_dado_T), 200)  
pdf_V = (1/np.sqrt(2*np.pi*var_V_dado_T)) * np.exp(-0.5*(x-mu_V_dado_T)**2/var_V_dado_T)  
plt.plot(x, pdf_V, 'b-', linewidth=2, label='P(V | T=25)')  

x2 = np.linspace(mu_P_dado_VT - 3*np.sqrt(var_P_dado_VT),  
                 mu_P_dado_VT + 3*np.sqrt(var_P_dado_VT), 200)  
pdf_P = (1/np.sqrt(2*np.pi*var_P_dado_VT)) * np.exp(-0.5*(x2-mu_P_dado_VT)**2/var_P_dado_VT)  
plt.plot(x2, pdf_P, 'r--', linewidth=2, label='P(P | V=10, T=22)')  
plt.xlabel('Valor da variável')  
plt.ylabel('Densidade de probabilidade')  
plt.title('Distribuições Condicionais')  
plt.legend()  
plt.grid(True)  

plt.tight_layout()  
plt.show()

import numpy as np

import matplotlib.pyplot as plt

import networkx as nx

from scipy.stats import multivariate_normal

# Definir a rede gaussiana

# Variáveis: T (temperatura), P (pressão), V (volume)

# T e P são independentes com médias e variâncias dadas

mu_T = 20.0

var_T = 4.0

mu_P = 101.0

var_P = 9.0

# V = 0.5*T - 0.3*P + erro, erro ~ N(0,1)

coef_T = 0.5

coef_P = -0.3

var_erro = 1.0

# Construir média conjunta (ordem: T, P, V)

mu = np.array([mu_T, mu_P, 0.0]) # média de V será calculada

mu_V = coef_T * mu_T + coef_P * mu_P

mu[2] = mu_V

# Construir matriz de covariância conjunta

# Cov(T,P)=0 (independentes)

cov = np.zeros((3,3))

cov[0,0] = var_T

cov[1,1] = var_P

# V = coef_T*T + coef_P*P + erro

# Cov(V,T) = coef_T * Var(T) + coef_P * Cov(P,T) = coef_T * var_T

cov[2,0] = coef_T * var_T

cov[0,2] = cov[2,0]

# Cov(V,P) = coef_T * Cov(T,P) + coef_P * Var(P) = coef_P * var_P

cov[2,1] = coef_P * var_P

cov[1,2] = cov[2,1]

# Var(V) = coef_T^2 * Var(T) + coef_P^2 * Var(P) + Var(erro)

cov[2,2] = coef_T**2 * var_T + coef_P**2 * var_P + var_erro

# Inferência condicional por fórmula para normais multivariadas

def condicional(mu, cov, idx_obs, valores_obs, idx_pred):

# idx_obs: lista de índices observados

# valores_obs: valores correspondentes

# idx_pred: índice da variável a prever

# Retorna (média, variância) condicional

mu_obs = mu[idx_obs]

mu_pred = mu[idx_pred]

cov_obs = cov[np.ix_(idx_obs, idx_obs)]

cov_pred_obs = cov[idx_pred, idx_obs]

# Média condicional

inv_cov_obs = np.linalg.inv(cov_obs)

mu_cond = mu_pred + cov_pred_obs @ inv_cov_obs @ (valores_obs - mu_obs)

var_cond = cov[idx_pred, idx_pred] - cov_pred_obs @ inv_cov_obs @ cov_pred_obs.T

return mu_cond, var_cond

# 1. P(V | T=25)

mu_V_dado_T, var_V_dado_T = condicional(mu, cov, [0], [25], 2)

print(f"P(V | T=25) -> média = {mu_V_dado_T:.4f}, variância = {var_V_dado_T:.4f}")

# 2. P(P | V=10, T=22)

mu_P_dado_VT, var_P_dado_VT = condicional(mu, cov, [2,0], [10,22], 1)

print(f"P(P | V=10, T=22) -> média = {mu_P_dado_VT:.4f}, variância = {var_P_dado_VT:.4f}")

# Plotar estrutura da rede

G = nx.DiGraph()

G.add_edges_from([('T', 'V'), ('P', 'V')])

pos = {'T': (0, 1), 'P': (0, 0), 'V': (1.5, 0.5)}

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

plt.subplot(1, 2, 1)

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

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

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

plt.title('Rede Gaussiana - T, P, V')

plt.subplot(1, 2, 2)

# Plotar distribuições condicionais

x = np.linspace(mu_V_dado_T - 3*np.sqrt(var_V_dado_T),

mu_V_dado_T + 3*np.sqrt(var_V_dado_T), 200)

pdf_V = (1/np.sqrt(2*np.pi*var_V_dado_T)) * np.exp(-0.5*(x-mu_V_dado_T)**2/var_V_dado_T)

plt.plot(x, pdf_V, 'b-', linewidth=2, label='P(V | T=25)')

x2 = np.linspace(mu_P_dado_VT - 3*np.sqrt(var_P_dado_VT),

mu_P_dado_VT + 3*np.sqrt(var_P_dado_VT), 200)

pdf_P = (1/np.sqrt(2*np.pi*var_P_dado_VT)) * np.exp(-0.5*(x2-mu_P_dado_VT)**2/var_P_dado_VT)

plt.plot(x2, pdf_P, 'r--', linewidth=2, label='P(P | V=10, T=22)')

plt.xlabel('Valor da variável')

plt.ylabel('Densidade de probabilidade')

plt.title('Distribuições Condicionais')

plt.legend()

plt.grid(True)

plt.tight_layout()

plt.show()

Este código implementa uma rede gaussiana com inferência analítica. A estrutura do grafo mostra a dependência de V em T e P. As curvas de densidade mostram as distribuições condicionais solicitadas. A inferência é exata e eficiente, usando apenas álgebra linear. Para iniciantes, este exemplo conecta redes bayesianas a dados contínuos. Redes contínuas são, portanto, uma extensão natural e poderosa.

Redes Bayesianas com Variaveis Discretas

16/07/202618/06/2026 Por antonino

O que são redes bayesianas com variáveis discretas?

Redes bayesianas com variáveis discretas são modelos probabilísticos onde cada nó assume valores categóricos finitos. Esses valores podem ser binários (sim/não), ordinais (baixo/médio/alto) ou nominais (cor/forma). Cada nó possui uma tabela de probabilidade condicional (CPT) que lista todas as combinações possíveis. Por exemplo, um nó com 3 pais binários terá 2³ = 8 entradas na sua CPT. A distribuição conjunta é o produto de todas as CPTs, como nas redes contínuas. Contudo, o raciocínio é feito por contagem e soma, não por integrais. Isso torna a inferência exata viável para redes de tamanho moderado. Variáveis discretas são naturais em diagnósticos, classificação e sistemas especialistas. Elas também são mais fáceis de interpretar por seres humanos não-técnicos.

Características fundamentais

Essas redes possuem três características marcantes que as distinguem. Primeiro, as CPTs são matrizes de probabilidade que somam 1 para cada linha. Segundo, a independência condicional é testada por testes qui-quadrado ou mutual information. Terceiro, a inferência pode ser feita por eliminação de variáveis, que é exata. A aprendizagem de parâmetros é feita por máxima verossimilhança (contagens) ou suavização de Laplace. A suavização evita probabilidades zero para combinações não observadas nos dados. Além disso, a estrutura pode ser aprendida por busca gulosa usando BIC ou AIC. Redes discretas são amplamente suportadas por bibliotecas como pgmpy e bnlearn.

Vantagens e aplicações típicas

A principal vantagem é a simplicidade computacional e interpretabilidade. Elas são usadas em sistemas de suporte à decisão médica (ex.: diagnóstico de gripe x covid). Também são aplicadas em filtros de spam, sistemas de recomendação e mineração de dados. Outra vantagem é a facilidade de incorporar conhecimento de especialistas via CPTs. Contudo, o número de parâmetros cresce exponencialmente com o número de pais. Para lidar com isso, usa-se estruturas esparsas ou árvores de decisão nas CPTs.

O tratamento de variáveis discretas é mais antigo e consolidado na literatura. Modelos como o classificador Naive Bayes são um caso especial com um único nó pai. Redes mais complexas podem ter múltiplas camadas de dependência entre variáveis. A inferência por eliminação de variáveis elimina nós não observados por soma. Isso reduz o problema a consultas condicionais simples de ser calculadas. Para redes grandes (dezenas de nós), usa-se amostragem de Gibbs ou MCMC. A amostragem gera aproximações, mas é escalável e fácil de implementar. A suavização de Laplace adiciona pseudocontagens para evitar overfitting. Isso é especialmente importante quando os dados são escassos. Redes bayesianas discretas também podem modelar séries temporais com cadeias de Markov. Nesse caso, cada nó tem arestas do tempo t-1 para t. Elas são usadas em previsão de demanda e análise de séries climáticas. A estrutura pode ser visualizada como um diagrama de influência. Assim, redes discretas são uma ferramenta madura e amplamente aplicada.

Um exemplo clássico é o problema do “Carro Não Liga” com variáveis: Bateria (B), Gasolina (G), Partida (P), e Motor (M). Todas são binárias (boa/ruim, cheia/vazia, etc.). A rede calcula a probabilidade de cada causa dado que o motor não liga. Isso auxilia o mecânico a diagnosticar a falha de forma estruturada.

Enunciado do exemplo clássico

Implemente uma rede bayesiana discreta para o diagnóstico de um motor de carro. Variáveis: Bateria (B: 0=ruim, 1=boa), Gasolina (G: 0=vazia, 1=cheia), Partida (P: 0=não funciona, 1=funciona), Motor (M: 0=não liga, 1=liga). Relações: B e G influenciam P; P influencia M. Defina CPTs manualmente com valores razoáveis. Calcule P(B=0 | M=0) e P(G=0 | M=0) usando inferência exata. Plote a rede graficamente e uma barra com as probabilidades posteriores.

import numpy as np  
import matplotlib.pyplot as plt  
import networkx as nx  

# Definição da rede com variáveis discretas (binárias)  

# Priores: P(B) e P(G)  
P_B = {0: 0.1, 1: 0.9}   # 10% bateria ruim  
P_G = {0: 0.15, 1: 0.85} # 15% gasolina vazia  

# Condicional: P(P | B, G)  
# ordem: B,G -> P  
P_P_dado_BG = {  
    (0,0,0): 0.01, (0,0,1): 0.99,  # B=0,G=0, P=0 e P=1  
    (0,1,0): 0.05, (0,1,1): 0.95,  # B=0,G=1  
    (1,0,0): 0.10, (1,0,1): 0.90,  # B=1,G=0  
    (1,1,0): 0.02, (1,1,1): 0.98   # B=1,G=1  
}  

# Condicional: P(M | P)  
P_M_dado_P = {  
    (0,0): 0.01, (0,1): 0.99,  # P=0, M=0 e M=1  
    (1,0): 0.05, (1,1): 0.95   # P=1, M=0 e M=1  
}  

# Função de inferência por enumeração (exata)  
def inferir_discreto(variavel, evidencia):  
    # variáveis: B, G, P, M  
    # evidencia: dict {var: valor}  
    prob_total = {0: 0.0, 1: 0.0}  
    for b in (0,1):  
        for g in (0,1):  
            for p in (0,1):  
                for m in (0,1):  
                    # Verificar evidência  
                    ok = True  
                    if 'B' in evidencia and evidencia['B'] != b: ok = False  
                    if 'G' in evidencia and evidencia['G'] != g: ok = False  
                    if 'P' in evidencia and evidencia['P'] != p: ok = False  
                    if 'M' in evidencia and evidencia['M'] != m: ok = False  
                    if not ok:  
                        continue  
                    # Probabilidade conjunta  
                    p = P_B[b] * P_G[g] * P_P_dado_BG[(b,g,p)] * P_M_dado_P[(p,m)]  
                    if variavel == 'B':  
                        prob_total[b] += p  
                    elif variavel == 'G':  
                        prob_total[g] += p  
                    elif variavel == 'P':  
                        prob_total[p] += p  
                    elif variavel == 'M':  
                        prob_total[m] += p  
    soma = sum(prob_total.values())  
    if soma > 0:  
        prob_total[0] /= soma  
        prob_total[1] /= soma  
    return prob_total  

# Calcular P(B=0 | M=0) - bateria ruim dado que motor não liga  
P_B_dado_M0 = inferir_discreto('B', {'M': 0})  
print(f"P(B=0 | M=0) = {P_B_dado_M0[0]:.4f}")  
print(f"P(B=1 | M=0) = {P_B_dado_M0[1]:.4f}")  

# Calcular P(G=0 | M=0) - gasolina vazia dado que motor não liga  
P_G_dado_M0 = inferir_discreto('G', {'M': 0})  
print(f"P(G=0 | M=0) = {P_G_dado_M0[0]:.4f}")  
print(f"P(G=1 | M=0) = {P_G_dado_M0[1]:.4f}")  

# Plotar estrutura da rede  
G = nx.DiGraph()  
G.add_edges_from([('B', 'P'), ('G', 'P'), ('P', 'M')])  
pos = {'B': (0, 1), 'G': (0, 0), 'P': (1, 0.5), 'M': (2, 0.5)}  

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=12, font_weight='bold',  
        arrowsize=20, edge_color='gray', width=2)  
plt.title('Rede Bayesiana Discreta - Diagnóstico do Motor')  

plt.subplot(1, 2, 2)  
# Gráfico de barras para probabilidades posteriores  
categorias = ['B=0 (ruim)', 'B=1 (boa)', 'G=0 (vazia)', 'G=1 (cheia)']  
valores = [P_B_dado_M0[0], P_B_dado_M0[1], P_G_dado_M0[0], P_G_dado_M0[1]]  
cores = ['red', 'green', 'orange', 'blue']  
bars = plt.bar(categorias, valores, color=cores, edgecolor='black')  
plt.ylim(0, 1)  
plt.ylabel('Probabilidade dado M=0 (motor não liga)')  
plt.title('Probabilidades Posteriores das Causas')  
for bar, val in zip(bars, valores):  
    plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.02,  
             f'{val:.2f}', ha='center', va='bottom', fontweight='bold')  
plt.grid(axis='y', linestyle='--', alpha=0.7)  
plt.tight_layout()  
plt.show()

import numpy as np

import matplotlib.pyplot as plt

import networkx as nx

# Definição da rede com variáveis discretas (binárias)

# Priores: P(B) e P(G)

P_B = {0: 0.1, 1: 0.9} # 10% bateria ruim

P_G = {0: 0.15, 1: 0.85} # 15% gasolina vazia

# Condicional: P(P | B, G)

# ordem: B,G -> P

P_P_dado_BG = {

(0,0,0): 0.01, (0,0,1): 0.99, # B=0,G=0, P=0 e P=1

(0,1,0): 0.05, (0,1,1): 0.95, # B=0,G=1

(1,0,0): 0.10, (1,0,1): 0.90, # B=1,G=0

(1,1,0): 0.02, (1,1,1): 0.98 # B=1,G=1

}

# Condicional: P(M | P)

P_M_dado_P = {

(0,0): 0.01, (0,1): 0.99, # P=0, M=0 e M=1

(1,0): 0.05, (1,1): 0.95 # P=1, M=0 e M=1

}

# Função de inferência por enumeração (exata)

def inferir_discreto(variavel, evidencia):

# variáveis: B, G, P, M

# evidencia: dict {var: valor}

prob_total = {0: 0.0, 1: 0.0}

for b in (0,1):

for g in (0,1):

for p in (0,1):

for m in (0,1):

# Verificar evidência

ok = True

if 'B' in evidencia and evidencia['B'] != b: ok = False

if 'G' in evidencia and evidencia['G'] != g: ok = False

if 'P' in evidencia and evidencia['P'] != p: ok = False

if 'M' in evidencia and evidencia['M'] != m: ok = False

if not ok:

continue

# Probabilidade conjunta

p = P_B[b] * P_G[g] * P_P_dado_BG[(b,g,p)] * P_M_dado_P[(p,m)]

if variavel == 'B':

prob_total[b] += p

elif variavel == 'G':

prob_total[g] += p

elif variavel == 'P':

prob_total[p] += p

elif variavel == 'M':

prob_total[m] += p

soma = sum(prob_total.values())

if soma > 0:

prob_total[0] /= soma

prob_total[1] /= soma

return prob_total

# Calcular P(B=0 | M=0) - bateria ruim dado que motor não liga

P_B_dado_M0 = inferir_discreto('B', {'M': 0})

print(f"P(B=0 | M=0) = {P_B_dado_M0[0]:.4f}")

print(f"P(B=1 | M=0) = {P_B_dado_M0[1]:.4f}")

# Calcular P(G=0 | M=0) - gasolina vazia dado que motor não liga

P_G_dado_M0 = inferir_discreto('G', {'M': 0})

print(f"P(G=0 | M=0) = {P_G_dado_M0[0]:.4f}")

print(f"P(G=1 | M=0) = {P_G_dado_M0[1]:.4f}")

# Plotar estrutura da rede

G = nx.DiGraph()

G.add_edges_from([('B', 'P'), ('G', 'P'), ('P', 'M')])

pos = {'B': (0, 1), 'G': (0, 0), 'P': (1, 0.5), 'M': (2, 0.5)}

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=12, font_weight='bold',

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

plt.title('Rede Bayesiana Discreta - Diagnóstico do Motor')

plt.subplot(1, 2, 2)

# Gráfico de barras para probabilidades posteriores

categorias = ['B=0 (ruim)', 'B=1 (boa)', 'G=0 (vazia)', 'G=1 (cheia)']

valores = [P_B_dado_M0[0], P_B_dado_M0[1], P_G_dado_M0[0], P_G_dado_M0[1]]

cores = ['red', 'green', 'orange', 'blue']

bars = plt.bar(categorias, valores, color=cores, edgecolor='black')

plt.ylim(0, 1)

plt.ylabel('Probabilidade dado M=0 (motor não liga)')

plt.title('Probabilidades Posteriores das Causas')

for bar, val in zip(bars, valores):

plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.02,

f'{val:.2f}', ha='center', va='bottom', fontweight='bold')

plt.grid(axis='y', linestyle='--', alpha=0.7)

plt.tight_layout()

plt.show()

Este código implementa uma rede discreta com inferência por enumeração. A estrutura do grafo mostra a relação causal entre bateria, gasolina, partida e motor. As barras de probabilidade revelam que a bateria ruim é a causa mais provável. A gasolina vazia tem uma probabilidade menor, mas ainda significativa. Para iniciantes, este exemplo demonstra o poder diagnóstico das redes discretas. Elas são, portanto, ferramentas essenciais para sistemas baseados em regras.