Arquivo de Python - Página 8 de 31

Classificador Bayesiano Optimo

16/07/202618/06/2026 Por antonino

O que é o classificador bayesiano ótimo?

O classificador bayesiano ótimo é o modelo que minimiza a probabilidade de erro de classificação. Ele atribui uma amostra à classe com maior probabilidade a posteriori, dada a evidência. Essa regra é chamada de regra de decisão de Bayes ou MAP (maximum a posteriori). Diferentemente de classificadores heurísticos, ele é matematicamente provado como ótimo. A optimalidade vale para qualquer problema, desde que as distribuições sejam conhecidas. O erro mínimo alcançável é chamado de erro de Bayes ou erro irredutível. Esse erro é devido à sobreposição natural entre as distribuições das classes. Portanto, nenhum outro classificador pode superar o bayesiano ótimo em termos de erro médio. Ele serve como um limite inferior teórico para avaliar outros algoritmos.

Características fundamentais

O classificador bayesiano ótimo possui três características principais que o definem. Primeiro, ele requer o conhecimento completo das distribuições condicionais P(x|classe). Segundo, ele usa a probabilidade a priori P(classe) para cada categoria. Terceiro, a decisão é determinística: escolhe a classe com maior P(classe|x). Ele pode ser generalizado para custos assimétricos (risco de Bayes). Nesse caso, minimiza o risco esperado, não apenas o erro bruto. O classificador ótimo é a base teórica para todos os outros métodos de classificação.

Vantagens e limitações

A principal vantagem é a garantia de desempenho máximo sob o modelo assumido. Ele é usado como referência para validar classificadores aproximados (ex.: SVM, redes neurais). Também é essencial em problemas de decisão com custos desiguais (ex.: diagnósticos). Contudo, na prática, as distribuições verdadeiras são desconhecidas. Portanto, ele é mais um conceito teórico do que um algoritmo implementável diretamente.

O erro de Bayes é calculado integrando a região de sobreposição das distribuições. Para duas classes com distribuições normais de mesma variância, a fronteira é linear. Se as variâncias são diferentes, a fronteira torna-se quadrática (análise discriminante quadrática). O classificador ótimo pode ser visto como um modelo generativo perfeito. Ele não sofre de overfitting porque usa as distribuições verdadeiras, não estimadas. Na prática, usamos aproximações como Naive Bayes ou QDA (Quadratic Discriminant Analysis). Essas aproximações estimam as distribuições a partir dos dados de treino. Quanto melhores as estimativas, mais próximo do ótimo estará o classificador. A teoria do erro de Bayes é fundamental para entender o viés e a variância. Ela mostra que o erro total = erro de Bayes + erro de estimativa + erro de aproximação. Isso guia a escolha entre modelos mais flexíveis (mais viés) ou mais complexos (mais variância). O classificador ótimo também é usado em problemas de detecção de sinais (ROC). A curva ROC traça a taxa de verdadeiros positivos vs. falsos positivos para diferentes limiares. Assim, o classificador bayesiano ótimo é um pilar da teoria da decisão estatística.

Um exemplo clássico é a classificação de duas espécies de flores com base no comprimento da pétala. Suponha que os comprimentos sigam distribuições normais com médias 3 e 5, e desvio 0.5. O ponto de corte ótimo (onde as densidades se cruzam) é a média ponderada pelas priores. Se as priores forem iguais, o corte é (3+5)/2 = 4.0. Esse é o classificador ótimo.

Enunciado do exemplo clássico

Implemente o classificador bayesiano ótimo para um problema de duas classes com distribuições normais conhecidas. Classe 0: X ~ N(μ₀=2, σ₀²=1.5). Classe 1: X ~ N(μ₁=6, σ₁²=2.0). Priores: P(0)=0.6, P(1)=0.4. Calcule a função de decisão analiticamente e plote as densidades, os prioris e a região de decisão. Calcule o erro de Bayes (integral da menor densidade ponderada). Classifique um novo ponto x=4.5 e mostre as probabilidades posteriores.

import numpy as np  
import matplotlib.pyplot as plt  
from scipy.stats import norm  
from scipy.optimize import fsolve  

# Parâmetros das classes  
mu0, sigma0 = 2.0, np.sqrt(1.5)  
mu1, sigma1 = 6.0, np.sqrt(2.0)  
prior0 = 0.6  
prior1 = 0.4  

# Função densidade para cada classe  
def f0(x):  
    return norm.pdf(x, mu0, sigma0)  
def f1(x):  
    return norm.pdf(x, mu1, sigma1)  

# Função de decisão: P(0|x) = P(1|x) -> f0(x)*prior0 = f1(x)*prior1  
def decisao(x):  
    return f0(x)*prior0 - f1(x)*prior1  

# Encontrar o ponto de corte (raiz da equação)  
# Usar dois chutes iniciais  
x_corte = fsolve(decisao, [3.5, 5.5])  
# Pegar a raiz dentro do intervalo  
x_corte = x_corte[(x_corte > 0) & (x_corte < 10)][0]  
print(f"Ponto de corte ótimo: {x_corte:.4f}")  

# Classificador ótimo  
def classificar_otimo(x):  
    # Se x < corte -> classe 0, senão classe 1  
    return 0 if x < x_corte else 1  

# Testar um novo ponto  
x_novo = 4.5  
classe_pred = classificar_otimo(x_novo)  
# Calcular posteriores  
post0 = f0(x_novo)*prior0 / (f0(x_novo)*prior0 + f1(x_novo)*prior1)  
post1 = 1 - post0  
print(f"\nPara x = {x_novo}:")  
print(f"  P(Classe 0 | x) = {post0:.4f}")  
print(f"  P(Classe 1 | x) = {post1:.4f}")  
print(f"  Classe predita: {classe_pred}")  

# Calcular erro de Bayes (integral da área de sobreposição ponderada)  
# Definir a região de integração  
x_vals = np.linspace(-2, 10, 1000)  
# Decisão: classifica como 0 se x < x_corte, senão 1  
# Erro = P(1)*P(x∈R0|1) + P(0)*P(x∈R1|0)  
# R0 = região onde decidimos classe 0 (x < x_corte)  
erro_bayes = (prior1 * norm.cdf(x_corte, mu1, sigma1) +  
              prior0 * (1 - norm.cdf(x_corte, mu0, sigma0)))  
print(f"\nErro de Bayes (mínimo possível): {erro_bayes:.4f}")  

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

plt.subplot(1, 2, 1)  
x_grid = np.linspace(-2, 10, 500)  
plt.plot(x_grid, f0(x_grid), 'b-', linewidth=2, label=f'Classe 0: N({mu0},{sigma0**2:.1f})')  
plt.plot(x_grid, f1(x_grid), 'r-', linewidth=2, label=f'Classe 1: N({mu1},{sigma1**2:.1f})')  
plt.plot(x_grid, f0(x_grid)*prior0, 'b--', linewidth=1.5, label='Prior 0 * densidade')  
plt.plot(x_grid, f1(x_grid)*prior1, 'r--', linewidth=1.5, label='Prior 1 * densidade')  
plt.axvline(x_corte, color='green', linestyle=':', linewidth=3, label=f'Corte = {x_corte:.3f}')  
# Preencher região de erro (sobreposição)  
plt.fill_between(x_grid, np.minimum(f0(x_grid)*prior0, f1(x_grid)*prior1),  
                 alpha=0.3, color='gray', label='Área de erro')  
plt.xlabel('x')  
plt.ylabel('Densidade de probabilidade')  
plt.title('Classificador Bayesiano Ótimo - Densidades e Região de Erro')  
plt.legend()  
plt.grid(True)  

plt.subplot(1, 2, 2)  
# Mostrar posteriores para o novo ponto  
x_plot = np.linspace(-2, 10, 200)  
post0_plot = f0(x_plot)*prior0 / (f0(x_plot)*prior0 + f1(x_plot)*prior1)  
post1_plot = 1 - post0_plot  
plt.plot(x_plot, post0_plot, 'b-', label='P(Classe 0 | x)')  
plt.plot(x_plot, post1_plot, 'r-', label='P(Classe 1 | x)')  
plt.axhline(0.5, color='gray', linestyle='--', label='Limiar 0.5')  
plt.axvline(x_corte, color='green', linestyle=':', label=f'Corte = {x_corte:.3f}')  
plt.scatter([x_novo], [post0], color='blue', s=100, zorder=5, label=f'Novo x={x_novo}')  
plt.xlabel('x')  
plt.ylabel('Probabilidade a posteriori')  
plt.title('Probabilidades Posteriores')  
plt.legend()  
plt.grid(True)  

plt.tight_layout()  
plt.show()

import numpy as np

import matplotlib.pyplot as plt

from scipy.stats import norm

from scipy.optimize import fsolve

# Parâmetros das classes

mu0, sigma0 = 2.0, np.sqrt(1.5)

mu1, sigma1 = 6.0, np.sqrt(2.0)

prior0 = 0.6

prior1 = 0.4

# Função densidade para cada classe

def f0(x):

return norm.pdf(x, mu0, sigma0)

def f1(x):

return norm.pdf(x, mu1, sigma1)

# Função de decisão: P(0|x) = P(1|x) -> f0(x)*prior0 = f1(x)*prior1

def decisao(x):

return f0(x)*prior0 - f1(x)*prior1

# Encontrar o ponto de corte (raiz da equação)

# Usar dois chutes iniciais

x_corte = fsolve(decisao, [3.5, 5.5])

# Pegar a raiz dentro do intervalo

x_corte = x_corte[(x_corte > 0) & (x_corte < 10)][0]

print(f"Ponto de corte ótimo: {x_corte:.4f}")

# Classificador ótimo

def classificar_otimo(x):

# Se x < corte -> classe 0, senão classe 1

return 0 if x < x_corte else 1

# Testar um novo ponto

x_novo = 4.5

classe_pred = classificar_otimo(x_novo)

# Calcular posteriores

post0 = f0(x_novo)*prior0 / (f0(x_novo)*prior0 + f1(x_novo)*prior1)

post1 = 1 - post0

print(f"\nPara x = {x_novo}:")

print(f" P(Classe 0 | x) = {post0:.4f}")

print(f" P(Classe 1 | x) = {post1:.4f}")

print(f" Classe predita: {classe_pred}")

# Calcular erro de Bayes (integral da área de sobreposição ponderada)

# Definir a região de integração

x_vals = np.linspace(-2, 10, 1000)

# Decisão: classifica como 0 se x < x_corte, senão 1

# Erro = P(1)*P(x∈R0|1) + P(0)*P(x∈R1|0)

# R0 = região onde decidimos classe 0 (x < x_corte)

erro_bayes = (prior1 * norm.cdf(x_corte, mu1, sigma1) +

prior0 * (1 - norm.cdf(x_corte, mu0, sigma0)))

print(f"\nErro de Bayes (mínimo possível): {erro_bayes:.4f}")

# Plotar

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

plt.subplot(1, 2, 1)

x_grid = np.linspace(-2, 10, 500)

plt.plot(x_grid, f0(x_grid), 'b-', linewidth=2, label=f'Classe 0: N({mu0},{sigma0**2:.1f})')

plt.plot(x_grid, f1(x_grid), 'r-', linewidth=2, label=f'Classe 1: N({mu1},{sigma1**2:.1f})')

plt.plot(x_grid, f0(x_grid)*prior0, 'b--', linewidth=1.5, label='Prior 0 * densidade')

plt.plot(x_grid, f1(x_grid)*prior1, 'r--', linewidth=1.5, label='Prior 1 * densidade')

plt.axvline(x_corte, color='green', linestyle=':', linewidth=3, label=f'Corte = {x_corte:.3f}')

# Preencher região de erro (sobreposição)

plt.fill_between(x_grid, np.minimum(f0(x_grid)*prior0, f1(x_grid)*prior1),

alpha=0.3, color='gray', label='Área de erro')

plt.xlabel('x')

plt.ylabel('Densidade de probabilidade')

plt.title('Classificador Bayesiano Ótimo - Densidades e Região de Erro')

plt.legend()

plt.grid(True)

plt.subplot(1, 2, 2)

# Mostrar posteriores para o novo ponto

x_plot = np.linspace(-2, 10, 200)

post0_plot = f0(x_plot)*prior0 / (f0(x_plot)*prior0 + f1(x_plot)*prior1)

post1_plot = 1 - post0_plot

plt.plot(x_plot, post0_plot, 'b-', label='P(Classe 0 | x)')

plt.plot(x_plot, post1_plot, 'r-', label='P(Classe 1 | x)')

plt.axhline(0.5, color='gray', linestyle='--', label='Limiar 0.5')

plt.axvline(x_corte, color='green', linestyle=':', label=f'Corte = {x_corte:.3f}')

plt.scatter([x_novo], [post0], color='blue', s=100, zorder=5, label=f'Novo x={x_novo}')

plt.xlabel('x')

plt.ylabel('Probabilidade a posteriori')

plt.title('Probabilidades Posteriores')

plt.legend()

plt.grid(True)

plt.tight_layout()

plt.show()

Este código implementa o classificador ótimo com distribuições normais conhecidas. O ponto de corte é encontrado igualando as densidades ponderadas pelos prioris. A área sombreada em cinza representa o erro de Bayes (sobreposição). As posteriores para o novo ponto mostram a incerteza da classificação. O erro de Bayes calculado é o menor erro possível para esse problema. Para iniciantes, este exemplo conecta teoria estatística à decisão prática. O classificador bayesiano ótimo é, portanto, um referencial teórico fundamental.

Classificadores Bayesianos

16/07/202618/06/2026 Por antonino

O que são classificadores bayesianos?

Classificadores bayesianos são modelos probabilísticos que atribuem uma classe a uma amostra usando o teorema de Bayes. Eles calculam a probabilidade a posteriori de cada classe dado os atributos observados. A classe escolhida é aquela com maior probabilidade posterior (regra de decisão de Bayes). Esses classificadores são generativos: modelam a distribuição conjunta de atributos e classes. Diferentemente de modelos discriminativos, eles podem lidar com dados faltantes naturalmente. O classificador Naive Bayes é o mais famoso, assumindo independência condicional entre atributos. Apesar dessa suposição forte, ele funciona surpreendentemente bem na prática. Classificadores bayesianos também fornecem uma medida de incerteza em cada predição. Isso é crucial em aplicações críticas como diagnóstico médico e detecção de fraudes.

Características fundamentais

Esses classificadores possuem três características principais que os distinguem. Primeiro, eles exigem conhecimento prévio (prior) das probabilidades das classes. Segundo, a verossimilhança é calculada a partir da distribuição dos atributos em cada classe. Terceiro, a decisão é baseada na regra de Bayes com minimização do erro esperado. Eles podem ser paramétricos (assumindo distribuições como normal) ou não-paramétricos (kernel). Além disso, eles são facilmente atualizáveis com novos dados (aprendizado incremental). A complexidade de treinamento é baixa, especialmente no caso Naive Bayes.

Vantagens e aplicações típicas

A principal vantagem é a interpretabilidade e a robustez a ruídos. Eles são usados em filtros de spam, análise de sentimentos e classificação de textos. Também são aplicados em sistemas de recomendação e diagnósticos médicos. Contudo, a suposição de independência pode ser violada em dados reais.

O classificador Naive Bayes é derivado da suposição de que os atributos são independentes dado a classe. Isso simplifica o cálculo: P(classe | atributos) ∝ P(classe) * ∏ P(atributoᵢ | classe). Para atributos contínuos, assume-se frequentemente uma distribuição normal (Gaussian Naive Bayes). Para atributos discretos, usa-se frequências ou suavização de Laplace. A suavização evita probabilidades zero para combinações não vistas no treino. O classificador bayesiano ótimo (sem independência) requer a estimativa da conjunta completa. Isso é inviável para muitas variáveis, daí a popularidade do Naive Bayes. Outra variante é o TAN (Tree-Augmented Naive Bayes), que relaxa a independência. Ele adiciona arestas entre atributos para capturar correlações significativas. Apesar de mais complexo, o TAN melhora a acurácia em muitos conjuntos. Classificadores bayesianos também podem ser usados com prioris não-informativos. Isso é útil quando não se tem conhecimento prévio sobre as classes. A saída probabilística permite definir limiares de confiança para rejeição de decisões. Assim, classificadores bayesianos são ferramentas versáteis e didáticas.

Um exemplo clássico é a classificação de flores Iris (Setosa, Versicolor, Virginica) usando comprimento e largura das pétalas. O Naive Bayes gaussiano separa bem as classes com alta acurácia. A fronteira de decisão é suave e quadrática devido às diferentes variâncias.

Enunciado do exemplo clássico

Implemente um classificador Naive Bayes gaussiano para o dataset Iris (usando apenas duas características: comprimento e largura da pétala). Divida os dados em treino (70%) e teste (30%). Treine o modelo calculando médias e variâncias por classe. Classifique os dados de teste e calcule a acurácia. Plote a fronteira de decisão no espaço 2D e a matriz de confusão.

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

# Carregar dados Iris (apenas duas características)  
iris = load_iris()  
X = iris.data[:, 2:4]  # comprimento e largura da pétala  
y = iris.target  
nomes_classes = iris.target_names  

# Dividir treino/teste  
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)  

# Treinar 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:.3f}")  

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

# Plotar fronteira de decisão  
x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5  
y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5  
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.figure(figsize=(12, 5))  

# Gráfico 1: Fronteira de decisão  
plt.subplot(1, 2, 1)  
plt.contourf(xx, yy, Z, alpha=0.3, cmap='viridis')  
# Plotar pontos de treino e teste  
for i, classe in enumerate(nomes_classes):  
    idx_train = (y_train == i)  
    idx_test = (y_test == i)  
    plt.scatter(X_train[idx_train, 0], X_train[idx_train, 1],  
                marker='o', edgecolor='black', s=60, label=f'{classe} (treino)')  
    plt.scatter(X_test[idx_test, 0], X_test[idx_test, 1],  
                marker='x', edgecolor='red', s=80, label=f'{classe} (teste)')  
plt.xlabel('Comprimento da pétala (cm)')  
plt.ylabel('Largura da pétala (cm)')  
plt.title('Fronteira de Decisão - Naive Bayes Gaussiano')  
plt.legend()  
plt.grid(True)  

# Gráfico 2: Matriz de confusão  
plt.subplot(1, 2, 2)  
ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=nomes_classes).plot(ax=plt.gca(), cmap='Blues')  
plt.title(f'Matriz de Confusão (Acurácia = {acuracia:.3f})')  

plt.tight_layout()  
plt.show()  

# Mostrar probabilidades para uma nova flor  
nova_flor = np.array([[4.5, 1.2]])  # comprimento e largura da pétala  
probs = modelo.predict_proba(nova_flor)  
print(f"\nPrevisão para pétala (4.5, 1.2):")  
for i, classe in enumerate(nomes_classes):  
    print(f"  P({classe}) = {probs[0][i]:.3f}")  
print(f"Classe predita: {nomes_classes[modelo.predict(nova_flor)[0]]}")

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split

from sklearn.naive_bayes import GaussianNB

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

# Carregar dados Iris (apenas duas características)

iris = load_iris()

X = iris.data[:, 2:4] # comprimento e largura da pétala

y = iris.target

nomes_classes = iris.target_names

# Dividir treino/teste

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Treinar 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:.3f}")

# Matriz de confusão

cm = confusion_matrix(y_test, y_pred)

# Plotar fronteira de decisão

x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5

y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5

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.figure(figsize=(12, 5))

# Gráfico 1: Fronteira de decisão

plt.subplot(1, 2, 1)

plt.contourf(xx, yy, Z, alpha=0.3, cmap='viridis')

# Plotar pontos de treino e teste

for i, classe in enumerate(nomes_classes):

idx_train = (y_train == i)

idx_test = (y_test == i)

plt.scatter(X_train[idx_train, 0], X_train[idx_train, 1],

marker='o', edgecolor='black', s=60, label=f'{classe} (treino)')

plt.scatter(X_test[idx_test, 0], X_test[idx_test, 1],

marker='x', edgecolor='red', s=80, label=f'{classe} (teste)')

plt.xlabel('Comprimento da pétala (cm)')

plt.ylabel('Largura da pétala (cm)')

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

plt.legend()

plt.grid(True)

# Gráfico 2: Matriz de confusão

plt.subplot(1, 2, 2)

ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=nomes_classes).plot(ax=plt.gca(), cmap='Blues')

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

plt.tight_layout()

plt.show()

# Mostrar probabilidades para uma nova flor

nova_flor = np.array([[4.5, 1.2]]) # comprimento e largura da pétala

probs = modelo.predict_proba(nova_flor)

print(f"\nPrevisão para pétala (4.5, 1.2):")

for i, classe in enumerate(nomes_classes):

print(f" P({classe}) = {probs[0][i]:.3f}")

print(f"Classe predita: {nomes_classes[modelo.predict(nova_flor)[0]]}")

Este código treina um Naive Bayes gaussiano no dataset Iris com duas características. A fronteira de decisão mostra regiões quadráticas separando as três classes. A matriz de confusão revela o desempenho detalhado do classificador. O modelo também fornece probabilidades para novas amostras. Para iniciantes, este exemplo conecta teoria bayesiana à prática de classificação. Classificadores bayesianos são, portanto, uma porta de entrada para aprendizado supervisionado.