Arquivo de Python - Página 12 de 31

Redes Bayesianas

16/07/202618/06/2026 Por antonino

O que são redes bayesianas?

Redes bayesianas são modelos gráficos probabilísticos que representam relações de dependência entre variáveis. Cada nó é uma variável aleatória, e cada aresta direcionada indica influência causal ou condicional. A estrutura é um grafo acíclico direcionado (DAG), que proíbe ciclos de dependência. Cada nó possui uma tabela de probabilidade condicional (CPT) dado seus pais. A rede codifica a distribuição conjunta de todas as variáveis de forma fatorada. Isso reduz drasticamente o número de parâmetros necessários para modelar sistemas complexos. Por exemplo, com 10 variáveis binárias, a tabela conjunta teria 2^10 = 1024 valores. Com uma rede esparsa, esse número cai para poucas dezenas. Portanto, redes bayesianas são eficientes e interpretáveis para inferência sob incerteza.

Características fundamentais

As redes bayesianas possuem três características principais que as definem. Primeiro, elas são baseadas no teorema de Bayes para atualização de crenças. Segundo, a independência condicional é codificada pela estrutura do grafo. Dado seus pais, cada nó é independente de todos os seus não-descendentes. Terceiro, a inferência pode ser exata (por eliminação de variáveis) ou aproximada (MCMC). Elas também permitem aprendizado estrutural (descobrir o grafo) e paramétrico (estimar CPTs). Além disso, lidam naturalmente com dados faltantes usando expectativa-maximização. Redes bayesianas são robustas a overfitting quando prioris são usados.

Vantagens e aplicações típicas

A principal vantagem é a capacidade de raciocínio causal e diagnóstico. Elas são usadas em sistemas de suporte à decisão médica (ex.: diagnóstico de doenças). Também são aplicadas em detecção de falhas, mineração de dados e bioinformática. Outra vantagem é a transparência: cada aresta tem uma interpretação clara. Contudo, aprender a estrutura ótima é um problema NP-difícil em geral. Ainda assim, heurísticas como busca gulosa ou algoritmos genéticos são usadas.

A construção de uma rede bayesiana começa com a definição das variáveis relevantes. Em seguida, o especialista ou algoritmo define as arestas baseadas em dependências. Cada nó tem uma CPT que especifica P(nó | pais) para todas as combinações. A distribuição conjunta é o produto de todas as CPTs: P(X₁,…,Xₙ) = ∏ P(Xᵢ | pais). A inferência responde a perguntas como: qual a probabilidade de doença dado um sintoma? Isso é feito por propagação de crenças em redes com estrutura de árvore. Para redes gerais, usa-se o algoritmo de eliminação de variáveis ou amostragem. A amostragem de Gibbs é comum para aproximações quando o grafo é grande. Redes bayesianas dinâmicas estendem o modelo para séries temporais. Elas incluem arestas entre estados consecutivos, como em filtros de Kalman. Aprendizado de estrutura busca o DAG que melhor explica os dados observados. Medidas como BIC (Bayesian Information Criterion) ou AIC são usadas. A busca é feita por operadores de adição, remoção ou inversão de arestas. Assim, redes bayesianas são ferramentas versáteis para modelagem probabilística.

Um exemplo clássico é a rede de diagnóstico de pneumonia com variáveis: Febre, Tosse, Raio-X, e Doença. A febre e a tosse são sintomas que podem ser causados pela pneumonia. O raio-X é um teste que também depende da doença. A rede permite calcular P(Pneumonia | Febre=True, Tosse=True, Raio-X=Anormal).

Enunciado do exemplo clássico

Implemente uma rede bayesiana para o problema “Chuva” e “Gramado Molhado”. Variáveis: Chuva (R), Irrigação (I), Gramado Molhado (G), e Tempo Nublado (N). Relações: N influencia R; R e I influenciam G (cada um independente). Defina probabilidades condicionais manualmente. Calcule P(G | R=True) e P(R | G=True, I=False) usando inferência exata. Plote a estrutura da rede (grafo) e uma tabela com as probabilidades solicitadas.

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

# Definição da rede bayesiana (estrutura e CPTs)  

# Nós: N (Nublado), R (Chuva), I (Irrigação), G (Gramado Molhado)  
# Todos binários: 0 = Falso, 1 = Verdadeiro  

# Prior: P(N)  
P_N = {0: 0.4, 1: 0.6}  

# Condicional: P(R | N)  
P_R_dado_N = {  
    (0,0): 0.1, (0,1): 0.9,  # N=0, R=0 e R=1  
    (1,0): 0.3, (1,1): 0.7   # N=1, R=0 e R=1  
}  

# Prior: P(I)  
P_I = {0: 0.5, 1: 0.5}  

# Condicional: P(G | R, I)  
P_G_dado_R_I = {  
    (0,0,0): 0.1, (0,0,1): 0.9,  # R=0, I=0, G=0 e G=1  
    (0,1,0): 0.2, (0,1,1): 0.8,  # R=0, I=1  
    (1,0,0): 0.3, (1,0,1): 0.7,  # R=1, I=0  
    (1,1,0): 0.4, (1,1,1): 0.6   # R=1, I=1  
}  

# Função de inferência por enumeração (exata)  
def inferir(variavel, evidencia):  
    # Lista de todas as variáveis na ordem: N, R, I, G  
    # evidencia: dicionário {var: valor}  
    # Retorna P(variavel | evidencia)  
    vars_ = ['N', 'R', 'I', 'G']  
    # Gerar todas as combinações (0/1)  
    comb = [(n,r,i,g) for n in (0,1) for r in (0,1) for i in (0,1) for g in (0,1)]  

    prob_total = {0: 0.0, 1: 0.0}  
    for n,r,i,g in comb:  
        # Verificar evidência  
        ok = True  
        for v, val in evidencia.items():  
            if v == 'N' and n != val: ok = False  
            if v == 'R' and r != val: ok = False  
            if v == 'I' and i != val: ok = False  
            if v == 'G' and g != val: ok = False  
        if not ok:  
            continue  
        # Probabilidade conjunta  
        p = P_N[n] * P_R_dado_N[(n,r)] * P_I[i] * P_G_dado_R_I[(r,i,g)]  
        # Se a variável alvo é N  
        if variavel == 'N':  
            prob_total[n] += p  
        elif variavel == 'R':  
            prob_total[r] += p  
        elif variavel == 'I':  
            prob_total[i] += p  
        elif variavel == 'G':  
            prob_total[g] += p  

    # Normalizar para somar 1  
    soma = sum(prob_total.values())  
    if soma > 0:  
        prob_total[0] /= soma  
        prob_total[1] /= soma  
    return prob_total  

# Calcular P(G | R=True)  
P_G_dado_R = inferir('G', {'R': 1})  
print(f"P(G | R=True): P(G=0)={P_G_dado_R[0]:.4f}, P(G=1)={P_G_dado_R[1]:.4f}")  

# Calcular P(R | G=True, I=False)  
P_R_dado_G_I = inferir('R', {'G': 1, 'I': 0})  
print(f"P(R | G=True, I=False): P(R=0)={P_R_dado_G_I[0]:.4f}, P(R=1)={P_R_dado_G_I[1]:.4f}")  

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

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

plt.subplot(1, 2, 1)  
nx.draw(G, pos, with_labels=True, node_color='lightblue',  
        node_size=2000, font_size=12, font_weight='bold',  
        arrowsize=20, edge_color='gray', width=2)  
plt.title('Estrutura da Rede Bayesiana\n(Chuva e Gramado Molhado)')  

plt.subplot(1, 2, 2)  
# Tabela de probabilidades calculadas  
dados_tabela = [  
    ['P(G=1 | R=1)', f'{P_G_dado_R[1]:.4f}'],  
    ['P(G=0 | R=1)', f'{P_G_dado_R[0]:.4f}'],  
    ['P(R=1 | G=1, I=0)', f'{P_R_dado_G_I[1]:.4f}'],  
    ['P(R=0 | G=1, I=0)', f'{P_R_dado_G_I[0]:.4f}']  
]  
plt.axis('off')  
plt.table(cellText=dados_tabela, colLabels=['Consulta', 'Probabilidade'],  
          loc='center', cellLoc='center', colWidths=[0.6, 0.3])  
plt.title('Resultados da Inferência')  
plt.tight_layout()  
plt.show()

100

101

102

103

import numpy as np

import matplotlib.pyplot as plt

import networkx as nx

# Definição da rede bayesiana (estrutura e CPTs)

# Nós: N (Nublado), R (Chuva), I (Irrigação), G (Gramado Molhado)

# Todos binários: 0 = Falso, 1 = Verdadeiro

# Prior: P(N)

P_N = {0: 0.4, 1: 0.6}

# Condicional: P(R | N)

P_R_dado_N = {

(0,0): 0.1, (0,1): 0.9, # N=0, R=0 e R=1

(1,0): 0.3, (1,1): 0.7 # N=1, R=0 e R=1

}

# Prior: P(I)

P_I = {0: 0.5, 1: 0.5}

# Condicional: P(G | R, I)

P_G_dado_R_I = {

(0,0,0): 0.1, (0,0,1): 0.9, # R=0, I=0, G=0 e G=1

(0,1,0): 0.2, (0,1,1): 0.8, # R=0, I=1

(1,0,0): 0.3, (1,0,1): 0.7, # R=1, I=0

(1,1,0): 0.4, (1,1,1): 0.6 # R=1, I=1

}

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

def inferir(variavel, evidencia):

# Lista de todas as variáveis na ordem: N, R, I, G

# evidencia: dicionário {var: valor}

# Retorna P(variavel | evidencia)

vars_ = ['N', 'R', 'I', 'G']

# Gerar todas as combinações (0/1)

comb = [(n,r,i,g) for n in (0,1) for r in (0,1) for i in (0,1) for g in (0,1)]

prob_total = {0: 0.0, 1: 0.0}

for n,r,i,g in comb:

# Verificar evidência

ok = True

for v, val in evidencia.items():

if v == 'N' and n != val: ok = False

if v == 'R' and r != val: ok = False

if v == 'I' and i != val: ok = False

if v == 'G' and g != val: ok = False

if not ok:

continue

# Probabilidade conjunta

p = P_N[n] * P_R_dado_N[(n,r)] * P_I[i] * P_G_dado_R_I[(r,i,g)]

# Se a variável alvo é N

if variavel == 'N':

prob_total[n] += p

elif variavel == 'R':

prob_total[r] += p

elif variavel == 'I':

prob_total[i] += p

elif variavel == 'G':

prob_total[g] += p

# Normalizar para somar 1

soma = sum(prob_total.values())

if soma > 0:

prob_total[0] /= soma

prob_total[1] /= soma

return prob_total

# Calcular P(G | R=True)

P_G_dado_R = inferir('G', {'R': 1})

print(f"P(G | R=True): P(G=0)={P_G_dado_R[0]:.4f}, P(G=1)={P_G_dado_R[1]:.4f}")

# Calcular P(R | G=True, I=False)

P_R_dado_G_I = inferir('R', {'G': 1, 'I': 0})

print(f"P(R | G=True, I=False): P(R=0)={P_R_dado_G_I[0]:.4f}, P(R=1)={P_R_dado_G_I[1]:.4f}")

# Plotar estrutura da rede

G = nx.DiGraph()

G.add_edges_from([('N', 'R'), ('R', 'G'), ('I', 'G')])

pos = {'N': (0, 1), 'R': (1, 1), 'I': (1, 0), 'G': (2, 0.5)}

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

plt.subplot(1, 2, 1)

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

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

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

plt.title('Estrutura da Rede Bayesiana\n(Chuva e Gramado Molhado)')

plt.subplot(1, 2, 2)

# Tabela de probabilidades calculadas

dados_tabela = [

['P(G=1 | R=1)', f'{P_G_dado_R[1]:.4f}'],

['P(G=0 | R=1)', f'{P_G_dado_R[0]:.4f}'],

['P(R=1 | G=1, I=0)', f'{P_R_dado_G_I[1]:.4f}'],

['P(R=0 | G=1, I=0)', f'{P_R_dado_G_I[0]:.4f}']

]

plt.axis('off')

plt.table(cellText=dados_tabela, colLabels=['Consulta', 'Probabilidade'],

loc='center', cellLoc='center', colWidths=[0.6, 0.3])

plt.title('Resultados da Inferência')

plt.tight_layout()

plt.show()

Este código implementa uma rede bayesiana manual com inferência por enumeração. A estrutura do grafo mostra as dependências causais entre as variáveis. Os resultados da inferência respondem perguntas condicionais diretamente. A enumeração é exata para redes pequenas, mas escala mal para muitas variáveis. Para iniciantes, este exemplo demonstra a mecânica fundamental das redes bayesianas. Elas são, portanto, uma ferramenta poderosa e didática para raciocínio probabilístico.

IA Bayesiana

16/07/202618/06/2026 Por antonino

O que é a IA bayesiana?

A IA bayesiana é um ramo da inteligência artificial baseado no teorema de Bayes. Ela trata a incerteza de forma probabilística, atualizando crenças com novas evidências. Diferentemente da IA clássica, ela não produz respostas pontuais, mas distribuições de probabilidade. Cada predição vem acompanhada de um intervalo de confiança ou credibilidade. Isso é crucial para decisões críticas em medicina, finanças e robótica. A IA bayesiana incorpora conhecimento prévio (prior) e dados observados (likelihood). O resultado é uma distribuição a posteriori que combina ambas as fontes. Portanto, ela é naturalmente adaptativa e resistente a overfitting. Ela também permite aprendizado contínuo com a chegada de novos dados.

Características fundamentais da abordagem bayesiana

A IA bayesiana possui três pilares conceituais que a distinguem. Primeiro, a probabilidade é interpretada como grau de crença subjetiva. Segundo, o teorema de Bayes é a regra de atualização: P(A|B) = P(B|A)*P(A)/P(B). Terceiro, todas as inferências são feitas integrando sobre distribuições completas. Não há estimativas pontuais como máximo de verossimilhança sem incerteza. Além disso, a escolha do prior é fundamental e deve ser justificada. Prioris informativos aceleram a convergência; prioris fracos deixam os dados falar. A IA bayesiana também lida naturalmente com dados faltantes e hierárquicos. Ela é computacionalmente intensiva, mas métodos MCMC e variacionais aliviam isso.

Vantagens e aplicações típicas

A principal vantagem é a quantificação rigorosa da incerteza nas decisões. Isso é vital em sistemas autônomos que operam em ambientes ruidosos. Além disso, a IA bayesiana é interpretável, pois cada parâmetro tem um significado. Ela é usada em filtros de Kalman, redes bayesianas e otimização bayesiana. Também é aplicada em diagnóstico médico, detecção de fraudes e recomendação. Contudo, a escolha do prior pode ser subjetiva e influenciar os resultados. Ainda assim, a IA bayesiana é uma das abordagens mais fundamentais da estatística.

O teorema de Bayes foi formulado no século XVIII, mas sua aplicação em IA é recente. Com o aumento da capacidade computacional, ela se tornou viável em grande escala. Redes bayesianas modelam relações causais entre variáveis de forma gráfica. Cada nó é uma variável e cada aresta representa uma dependência probabilística. A inferência nessas redes é feita por propagação de crenças (belief propagation). Na otimização bayesiana, usa-se um modelo substituto (geralmente Gaussian Process). Ele guia a busca por máximos de funções caras de avaliar. A cada iteração, a função de aquisição equilibra exploração e explotação. Isso é amplamente usado em ajuste de hiperparâmetros de machine learning. A IA bayesiana também é a base de algoritmos de aprendizado por reforço. Ela permite que agentes aprendam políticas com incerteza sobre o ambiente. Sua robustez a ruído a torna superior a métodos determinísticos em muitos casos. Por fim, ela fornece intervalos de credibilidade, não apenas pontuações. Assim, a IA bayesiana é uma filosofia de modelagem tão poderosa quanto elegante.

Um exemplo clássico é o problema do diagnóstico médico com testes imperfeitos. Dada a prevalência de uma doença e a acurácia do teste, calcula-se a probabilidade pós-teste. O teorema de Bayes atualiza a crença inicial com o resultado do exame. Esse exemplo ilustra perfeitamente a essência da inferência bayesiana.

Enunciado do exemplo clássico

Implemente um classificador bayesiano ingênuo (Naive Bayes) para prever se um e-mail é spam. Use o conjunto de dados sintético com duas características: frequência de “grátis” e “urgente”. Gere 200 e-mails (100 spam, 100 não-spam) com distribuições Gaussianas. Treine o modelo calculando as probabilidades a priori e as verossimilhanças. Teste em 50 novos e-mails e plote a fronteira de decisão com os pontos de teste. Plote também a matriz de confusão e a acurácia do classificador.

import numpy as np  
import matplotlib.pyplot as plt  
from sklearn.naive_bayes import GaussianNB  
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay  

# Gerar dados sintéticos  
np.random.seed(42)  
n_train = 200  
n_test = 50  

# Spam: média alta para "grátis" e "urgente"  
spam_features = np.random.multivariate_normal([0.8, 0.7], [[0.1, 0.02], [0.02, 0.1]], n_train//2)  
# Não-spam: médias baixas  
nao_spam = np.random.multivariate_normal([0.2, 0.3], [[0.1, 0.02], [0.02, 0.1]], n_train//2)  

X_train = np.vstack([spam_features, nao_spam])  
y_train = np.array([1]*100 + [0]*100)  

# Dados de teste  
spam_test = np.random.multivariate_normal([0.8, 0.7], [[0.1, 0.02], [0.02, 0.1]], n_test//2)  
nao_spam_test = np.random.multivariate_normal([0.2, 0.3], [[0.1, 0.02], [0.02, 0.1]], n_test//2)  
X_test = np.vstack([spam_test, nao_spam_test])  
y_test = np.array([1]*25 + [0]*25)  

# Classificador Naive Bayes Gaussiano  
modelo = GaussianNB()  
modelo.fit(X_train, y_train)  
y_pred = modelo.predict(X_test)  
acuracia = np.mean(y_pred == y_test)  
print(f"Acurácia no teste: {acuracia:.2f}")  

# Matriz de confusão  
cm = confusion_matrix(y_test, y_pred)  

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

# 1. Fronteira de decisão  
plt.subplot(1, 2, 1)  
# Criar grade para plotar a fronteira  
x_min, x_max = X_train[:, 0].min()-0.2, X_train[:, 0].max()+0.2  
y_min, y_max = X_train[:, 1].min()-0.2, X_train[:, 1].max()+0.2  
xx, yy = np.meshgrid(np.linspace(x_min, x_max, 200),  
                     np.linspace(y_min, y_max, 200))  
Z = modelo.predict(np.c_[xx.ravel(), yy.ravel()])  
Z = Z.reshape(xx.shape)  
plt.contourf(xx, yy, Z, alpha=0.4, cmap='coolwarm', levels=2)  
# Plotar pontos de treino (transparentes) e teste (sólidos)  
plt.scatter(X_train[y_train==0,0], X_train[y_train==0,1], c='blue', alpha=0.3, label='Treino não-spam')  
plt.scatter(X_train[y_train==1,0], X_train[y_train==1,1], c='red', alpha=0.3, label='Treino spam')  
plt.scatter(X_test[y_test==0,0], X_test[y_test==0,1], c='blue', edgecolor='black', s=80, label='Teste não-spam')  
plt.scatter(X_test[y_test==1,0], X_test[y_test==1,1], c='red', edgecolor='black', s=80, label='Teste spam')  
plt.xlabel('Frequência de "grátis"')  
plt.ylabel('Frequência de "urgente"')  
plt.title('Fronteira de Decisão - Naive Bayes')  
plt.legend()  
plt.grid(True)  

# 2. Matriz de confusão  
plt.subplot(1, 2, 2)  
ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Não-spam', 'Spam']).plot(ax=plt.gca(), cmap='Blues')  
plt.title(f'Matriz de Confusão (Acurácia = {acuracia:.2f})')  
plt.tight_layout()  
plt.show()  

# Exemplo de inferência bayesiana manual (para um novo e-mail)  
novo_email = np.array([[0.6, 0.5]])  
prob_spam = modelo.predict_proba(novo_email)[0][1]  
print(f"\nNovo e-mail com grátis=0.6, urgente=0.5")  
print(f"Probabilidade de ser spam: {prob_spam:.3f}")  
print(f"Classificação: {'Spam' if prob_spam > 0.5 else 'Não-spam'}")

import numpy as np

import matplotlib.pyplot as plt

from sklearn.naive_bayes import GaussianNB

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

# Gerar dados sintéticos

np.random.seed(42)

n_train = 200

n_test = 50

# Spam: média alta para "grátis" e "urgente"

spam_features = np.random.multivariate_normal([0.8, 0.7], [[0.1, 0.02], [0.02, 0.1]], n_train//2)

# Não-spam: médias baixas

nao_spam = np.random.multivariate_normal([0.2, 0.3], [[0.1, 0.02], [0.02, 0.1]], n_train//2)

X_train = np.vstack([spam_features, nao_spam])

y_train = np.array([1]*100 + [0]*100)

# Dados de teste

spam_test = np.random.multivariate_normal([0.8, 0.7], [[0.1, 0.02], [0.02, 0.1]], n_test//2)

nao_spam_test = np.random.multivariate_normal([0.2, 0.3], [[0.1, 0.02], [0.02, 0.1]], n_test//2)

X_test = np.vstack([spam_test, nao_spam_test])

y_test = np.array([1]*25 + [0]*25)

# Classificador Naive Bayes Gaussiano

modelo = GaussianNB()

modelo.fit(X_train, y_train)

y_pred = modelo.predict(X_test)

acuracia = np.mean(y_pred == y_test)

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

# Matriz de confusão

cm = confusion_matrix(y_test, y_pred)

# Gráficos

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

# 1. Fronteira de decisão

plt.subplot(1, 2, 1)

# Criar grade para plotar a fronteira

x_min, x_max = X_train[:, 0].min()-0.2, X_train[:, 0].max()+0.2

y_min, y_max = X_train[:, 1].min()-0.2, X_train[:, 1].max()+0.2

xx, yy = np.meshgrid(np.linspace(x_min, x_max, 200),

np.linspace(y_min, y_max, 200))

Z = modelo.predict(np.c_[xx.ravel(), yy.ravel()])

Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.4, cmap='coolwarm', levels=2)

# Plotar pontos de treino (transparentes) e teste (sólidos)

plt.scatter(X_train[y_train==0,0], X_train[y_train==0,1], c='blue', alpha=0.3, label='Treino não-spam')

plt.scatter(X_train[y_train==1,0], X_train[y_train==1,1], c='red', alpha=0.3, label='Treino spam')

plt.scatter(X_test[y_test==0,0], X_test[y_test==0,1], c='blue', edgecolor='black', s=80, label='Teste não-spam')

plt.scatter(X_test[y_test==1,0], X_test[y_test==1,1], c='red', edgecolor='black', s=80, label='Teste spam')

plt.xlabel('Frequência de "grátis"')

plt.ylabel('Frequência de "urgente"')

plt.title('Fronteira de Decisão - Naive Bayes')

plt.legend()

plt.grid(True)

# 2. Matriz de confusão

plt.subplot(1, 2, 2)

ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Não-spam', 'Spam']).plot(ax=plt.gca(), cmap='Blues')

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

plt.tight_layout()

plt.show()

# Exemplo de inferência bayesiana manual (para um novo e-mail)

novo_email = np.array([[0.6, 0.5]])

prob_spam = modelo.predict_proba(novo_email)[0][1]

print(f"\nNovo e-mail com grátis=0.6, urgente=0.5")

print(f"Probabilidade de ser spam: {prob_spam:.3f}")

print(f"Classificação: {'Spam' if prob_spam > 0.5 else 'Não-spam'}")

Este código usa o Gaussian Naive Bayes do scikit-learn para classificação. A fronteira de decisão mostra como o modelo separa as duas classes. A matriz de confusão revela o desempenho detalhado do classificador. O exemplo final demonstra a inferência probabilística para um novo e-mail. Para iniciantes, este exemplo conecta o teorema de Bayes à prática. A IA bayesiana é, portanto, uma abordagem fundamental e acessível.