Arquivo de Python - Página 20 de 92

Resolvendo quebra-cabeças complexos: como o GPC decifra padrões não-lineares no problema XOR

19/12/202531/10/2025 Por antonino

Imagine que você está em um jogo de estratégia onde precisa tomar decisões baseadas em duas condições: se está chovendo E se tem guarda-chuva, ou se não está chovendo E não tem guarda-chuva – em ambos os casos você fica seco. Mas se apenas uma condição for verdadeira, você se molha. Este padrão “ou um ou outro, mas não ambos” é exatamente o problema XOR – um desafio clássico que modelos lineares simples não conseguem resolver. O GPC brilha nestas situações, mapeando fronteiras de decisão complexas com precisão probabilística.

Como isso funciona na prática?

O problema XOR é famoso por ser não linearmente separável – você não pode traçar uma única linha reta para separar as classes. Enquanto classificadores lineares como regressão logística falham miseravelmente aqui, o GPC usa kernels como o RBF para mapear os dados para um espaço de dimensão superior onde se tornam linearmente separáveis. Diferentemente de redes neurais que também resolvem XOR mas são “caixas pretas”, o GPC fornece probabilidades calibradas que mostram não apenas a decisão, mas o quão confiante ele está em cada região do espaço de características.

Mãos na massa: visualizando o GPC no problema XOR

"""
Ilustração do Gaussian Process Classifier no problema XOR
Demonstra como o GPC resolve problemas não-linearmente separáveis
"""

import numpy as np
import matplotlib.pyplot as plt
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF, Matern
from sklearn.linear_model import LogisticRegression
from sklearn.inspection import DecisionBoundaryDisplay

# Criando o dataset XOR clássico
def criar_dataset_xor(ruido=0.1):
    """Cria o problema XOR com quatro clusters bem definidos"""
    np.random.seed(42)
    
    # Pontos para cada quadrante do XOR
    # Classe 0: (0,0) e (1,1) | Classe 1: (0,1) e (1,0)
    n_pontos = 50
    X00 = np.random.multivariate_normal([0, 0], [[ruido, 0], [0, ruido]], n_pontos)
    X11 = np.random.multivariate_normal([1, 1], [[ruido, 0], [0, ruido]], n_pontos)
    X01 = np.random.multivariate_normal([0, 1], [[ruido, 0], [0, ruido]], n_pontos)
    X10 = np.random.multivariate_normal([1, 0], [[ruido, 0], [0, ruido]], n_pontos)
    
    X = np.vstack([X00, X11, X01, X10])
    y = np.hstack([np.zeros(n_pontos * 2), np.ones(n_pontos * 2)])
    
    return X, y

X, y = criar_dataset_xor(ruido=0.05)

print("Dataset XOR criado:")
print(f"Forma dos dados: {X.shape}")
print(f"Distribuição das classes: {np.sum(y==0)} pontos classe 0, {np.sum(y==1)} pontos classe 1")
print("Padrão XOR: pontos (0,0) e (1,1) são classe 0, pontos (0,1) e (1,0) são classe 1")

# Criando e treinando os modelos
kernel_rbf = 1.0 * RBF(length_scale=1.0)
gpc = GaussianProcessClassifier(kernel=kernel_rbf, random_state=42)

# Comparando com regressão logística (que deve falhar)
logreg = LogisticRegression(random_state=42)

print("\nTreinando modelos...")
gpc.fit(X, y)
logreg.fit(X, y)

print(f"Kernel GPC otimizado: {gpc.kernel_}")

# Criando grid para visualização
xx, yy = np.meshgrid(np.linspace(-0.5, 1.5, 100),
                     np.linspace(-0.5, 1.5, 100))
X_grid = np.c_[xx.ravel(), yy.ravel()]

# Previsões dos modelos
Z_gpc = gpc.predict_proba(X_grid)[:, 1].reshape(xx.shape)
Z_logreg = logreg.predict_proba(X_grid)[:, 1].reshape(xx.shape)

# Visualização comparativa
fig, axes = plt.subplots(2, 3, figsize=(18, 12))

# Plot 1: Dados originais
scatter = axes[0, 0].scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.8, edgecolors='black')
axes[0, 0].set_title('Dataset XOR Original\n(Padrão Não-Linearmente Separável)')
axes[0, 0].set_xlabel('Característica 1')
axes[0, 0].set_ylabel('Característica 2')
plt.colorbar(scatter, ax=axes[0, 0])

# Plot 2: Regressão Logística (deve falhar)
contour_logreg = axes[0, 1].contourf(xx, yy, Z_logreg, levels=20, alpha=0.6, cmap='bwr')
axes[0, 1].scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.8, edgecolors='black')
axes[0, 1].set_title('Regressão Logística\n(Falha em capturar padrão XOR)')
axes[0, 1].set_xlabel('Característica 1')
axes[0, 1].set_ylabel('Característica 2')
plt.colorbar(contour_logreg, ax=axes[0, 1])

# Plot 3: GPC - Probabilidades
contour_gpc = axes[0, 2].contourf(xx, yy, Z_gpc, levels=20, alpha=0.6, cmap='bwr')
axes[0, 2].scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.8, edgecolors='black')
axes[0, 2].set_title('GPC - Probabilidades\n(Captura perfeitamente o padrão XOR)')
axes[0, 2].set_xlabel('Característica 1')
axes[0, 2].set_ylabel('Característica 2')
plt.colorbar(contour_gpc, ax=axes[0, 2])

# Plot 4: GPC - Decisão binária
Z_gpc_binary = (Z_gpc > 0.5).astype(int)
contour_binary = axes[1, 0].contourf(xx, yy, Z_gpc_binary, levels=20, alpha=0.6, cmap='bwr')
axes[1, 0].scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.8, edgecolors='black')
axes[1, 0].set_title('GPC - Decisão Binária\n(Fronteira de decisão complexa)')
axes[1, 0].set_xlabel('Característica 1')
axes[1, 0].set_ylabel('Característica 2')

# Plot 5: GPC - Incerteza
incerteza = 1 - 2 * np.abs(Z_gpc - 0.5)  # Máxima quando probabilidade = 0.5
contour_unc = axes[1, 1].contourf(xx, yy, incerteza, levels=20, alpha=0.6, cmap='viridis')
axes[1, 1].scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.8, edgecolors='black')
axes[1, 1].set_title('GPC - Mapa de Incerteza\n(Alta incerteza nas fronteiras)')
axes[1, 1].set_xlabel('Característica 1')
axes[1, 1].set_ylabel('Característica 2')
plt.colorbar(contour_unc, ax=axes[1, 1])

# Plot 6: Comparação de desempenho
models = ['Regressão Logística', 'GPC']
scores = [logreg.score(X, y), gpc.score(X, y)]
bars = axes[1, 2].bar(models, scores, color=['red', 'blue'], alpha=0.7)
axes[1, 2].set_ylim(0, 1.1)
axes[1, 2].set_title('Comparação de Acurácia')
axes[1, 2].set_ylabel('Acurácia')

# Adicionando valores nas barras
for bar, score in zip(bars, scores):
    height = bar.get_height()
    axes[1, 2].text(bar.get_x() + bar.get_width()/2., height + 0.01,
                   f'{score:.3f}', ha='center', va='bottom')

plt.tight_layout()
plt.show()

# Análise detalhada das previsões
print("\n=== ANÁLISE DETALHADA DAS PREVISÕES ===")
print("Pontos de teste e suas probabilidades GPC:")

pontos_teste = np.array([[0.1, 0.1], [0.9, 0.9], [0.1, 0.9], [0.9, 0.1],
                         [0.5, 0.5]])  # Ponto central - alta incerteza

for i, ponto in enumerate(pontos_teste):
    prob_gpc = gpc.predict_proba([ponto])[0, 1]
    prob_logreg = logreg.predict_proba([ponto])[0, 1]
    
    print(f"\nPonto {ponto}:")
    print(f"  GPC: probabilidade classe 1 = {prob_gpc:.4f}")
    print(f"  Regressão Logística: probabilidade classe 1 = {prob_logreg:.4f}")
    print(f"  Incerteza GPC: {1 - 2 * abs(prob_gpc - 0.5):.4f}")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

"""

Ilustração do Gaussian Process Classifier no problema XOR

Demonstra como o GPC resolve problemas não-linearmente separáveis

"""

import numpy as np

import matplotlib.pyplot as plt

from sklearn.gaussian_process import GaussianProcessClassifier

from sklearn.gaussian_process.kernels import RBF, Matern

from sklearn.linear_model import LogisticRegression

from sklearn.inspection import DecisionBoundaryDisplay

# Criando o dataset XOR clássico

def criar_dataset_xor(ruido=0.1):

"""Cria o problema XOR com quatro clusters bem definidos"""

np.random.seed(42)

# Pontos para cada quadrante do XOR

# Classe 0: (0,0) e (1,1) | Classe 1: (0,1) e (1,0)

n_pontos = 50

X00 = np.random.multivariate_normal([0, 0], [[ruido, 0], [0, ruido]], n_pontos)

X11 = np.random.multivariate_normal([1, 1], [[ruido, 0], [0, ruido]], n_pontos)

X01 = np.random.multivariate_normal([0, 1], [[ruido, 0], [0, ruido]], n_pontos)

X10 = np.random.multivariate_normal([1, 0], [[ruido, 0], [0, ruido]], n_pontos)

X = np.vstack([X00, X11, X01, X10])

y = np.hstack([np.zeros(n_pontos * 2), np.ones(n_pontos * 2)])

return X, y

X, y = criar_dataset_xor(ruido=0.05)

print("Dataset XOR criado:")

print(f"Forma dos dados: {X.shape}")

print(f"Distribuição das classes: {np.sum(y==0)} pontos classe 0, {np.sum(y==1)} pontos classe 1")

print("Padrão XOR: pontos (0,0) e (1,1) são classe 0, pontos (0,1) e (1,0) são classe 1")

# Criando e treinando os modelos

kernel_rbf = 1.0 * RBF(length_scale=1.0)

gpc = GaussianProcessClassifier(kernel=kernel_rbf, random_state=42)

# Comparando com regressão logística (que deve falhar)

logreg = LogisticRegression(random_state=42)

print("\nTreinando modelos...")

gpc.fit(X, y)

logreg.fit(X, y)

print(f"Kernel GPC otimizado: {gpc.kernel_}")

# Criando grid para visualização

xx, yy = np.meshgrid(np.linspace(-0.5, 1.5, 100),

np.linspace(-0.5, 1.5, 100))

X_grid = np.c_[xx.ravel(), yy.ravel()]

# Previsões dos modelos

Z_gpc = gpc.predict_proba(X_grid)[:, 1].reshape(xx.shape)

Z_logreg = logreg.predict_proba(X_grid)[:, 1].reshape(xx.shape)

# Visualização comparativa

fig, axes = plt.subplots(2, 3, figsize=(18, 12))

# Plot 1: Dados originais

scatter = axes[0, 0].scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.8, edgecolors='black')

axes[0, 0].set_title('Dataset XOR Original\n(Padrão Não-Linearmente Separável)')

axes[0, 0].set_xlabel('Característica 1')

axes[0, 0].set_ylabel('Característica 2')

plt.colorbar(scatter, ax=axes[0, 0])

# Plot 2: Regressão Logística (deve falhar)

contour_logreg = axes[0, 1].contourf(xx, yy, Z_logreg, levels=20, alpha=0.6, cmap='bwr')

axes[0, 1].scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.8, edgecolors='black')

axes[0, 1].set_title('Regressão Logística\n(Falha em capturar padrão XOR)')

axes[0, 1].set_xlabel('Característica 1')

axes[0, 1].set_ylabel('Característica 2')

plt.colorbar(contour_logreg, ax=axes[0, 1])

# Plot 3: GPC - Probabilidades

contour_gpc = axes[0, 2].contourf(xx, yy, Z_gpc, levels=20, alpha=0.6, cmap='bwr')

axes[0, 2].scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.8, edgecolors='black')

axes[0, 2].set_title('GPC - Probabilidades\n(Captura perfeitamente o padrão XOR)')

axes[0, 2].set_xlabel('Característica 1')

axes[0, 2].set_ylabel('Característica 2')

plt.colorbar(contour_gpc, ax=axes[0, 2])

# Plot 4: GPC - Decisão binária

Z_gpc_binary = (Z_gpc > 0.5).astype(int)

contour_binary = axes[1, 0].contourf(xx, yy, Z_gpc_binary, levels=20, alpha=0.6, cmap='bwr')

axes[1, 0].scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.8, edgecolors='black')

axes[1, 0].set_title('GPC - Decisão Binária\n(Fronteira de decisão complexa)')

axes[1, 0].set_xlabel('Característica 1')

axes[1, 0].set_ylabel('Característica 2')

# Plot 5: GPC - Incerteza

incerteza = 1 - 2 * np.abs(Z_gpc - 0.5) # Máxima quando probabilidade = 0.5

contour_unc = axes[1, 1].contourf(xx, yy, incerteza, levels=20, alpha=0.6, cmap='viridis')

axes[1, 1].scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.8, edgecolors='black')

axes[1, 1].set_title('GPC - Mapa de Incerteza\n(Alta incerteza nas fronteiras)')

axes[1, 1].set_xlabel('Característica 1')

axes[1, 1].set_ylabel('Característica 2')

plt.colorbar(contour_unc, ax=axes[1, 1])

# Plot 6: Comparação de desempenho

models = ['Regressão Logística', 'GPC']

scores = [logreg.score(X, y), gpc.score(X, y)]

bars = axes[1, 2].bar(models, scores, color=['red', 'blue'], alpha=0.7)

axes[1, 2].set_ylim(0, 1.1)

axes[1, 2].set_title('Comparação de Acurácia')

axes[1, 2].set_ylabel('Acurácia')

# Adicionando valores nas barras

for bar, score in zip(bars, scores):

height = bar.get_height()

axes[1, 2].text(bar.get_x() + bar.get_width()/2., height + 0.01,

f'{score:.3f}', ha='center', va='bottom')

plt.tight_layout()

plt.show()

# Análise detalhada das previsões

print("\n=== ANÁLISE DETALHADA DAS PREVISÕES ===")

print("Pontos de teste e suas probabilidades GPC:")

pontos_teste = np.array([[0.1, 0.1], [0.9, 0.9], [0.1, 0.9], [0.9, 0.1],

[0.5, 0.5]]) # Ponto central - alta incerteza

for i, ponto in enumerate(pontos_teste):

prob_gpc = gpc.predict_proba([ponto])[0, 1]

prob_logreg = logreg.predict_proba([ponto])[0, 1]

print(f"\nPonto {ponto}:")

print(f" GPC: probabilidade classe 1 = {prob_gpc:.4f}")

print(f" Regressão Logística: probabilidade classe 1 = {prob_logreg:.4f}")

print(f" Incerteza GPC: {1 - 2 * abs(prob_gpc - 0.5):.4f}")

Os detalhes que fazem diferença

O sucesso do GPC no problema XOR demonstra o poder dos kernels para capturar relações não-lineares complexas. Enquanto a regressão logística tenta desesperadamente ajustar um plano linear que nunca funcionará, o kernel RBF do GPC mapeia os pontos para um espaço onde a separação torna-se possível. Contudo, a escolha do parâmetro de length_scale é crucial – valores muito pequenos podem levar a overfitting, enquanto valores muito grandes não capturam a complexidade necessária. Analogamente importante é entender que as áreas de alta incerteza (probabilidades perto de 0.5) correspondem exatamente às regiões entre os clusters, onde o modelo honestamente admite sua falta de informação.

Kernel RBF: Mapeia dados para espaço de alta dimensão onde se tornam linearmente separáveis
Length_scale: Controla a suavidade da fronteira de decisão
Incerteza natural: Áreas entre clusters mostram alta incerteza, não indecisão arbitrária
Interpretabilidade: Probabilidades refletem verdadeira confiança baseada na distribuição dos dados

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Por que a regressão logística falha tão feio no XOR?” Excelente questão! A regressão logística é inerentemente linear – ela só pode traçar uma linha reta (ou plano) para separar classes. O padrão XOR requer uma fronteira não-linear como uma cruz ou dois segmentos desconectados. Uma confusão comum é pensar que adicionar features polinomiais resolveria o problema – até funciona, mas requer saber antecipadamente a transformação correta. Outra dúvida frequente: “O GPC sempre resolve problemas não-lineares?” Sim, desde que o kernel apropriado seja usado, mas o custo computacional pode ser proibitivo para datasets muito grandes.

Para onde ir agora?

Experimente o GPC em outros problemas não-linearmente separáveis além do XOR. Tente diferentes kernels como Matern ou kernels compostos para padrões mais complexos. Observe como as probabilidades e incertezas se comportam em diferentes regiões do espaço de features. O momento “aha!” acontece quando você visualiza como o GPC cria fronteiras de decisão complexas que seriam impossíveis para métodos lineares, enquanto mantém uma medida honesta de sua própria incerteza.

Assuntos relacionados

Para entender profundamente esta aplicação, estude:

Teoria de kernels: o truque do kernel e espaços de características
Separabilidade linear: quando problemas podem ser resolvidos por métodos lineares
Funções de base radial: fundamento matemático dos kernels RBF
Mapeamento não-linear: transformações que tornam dados linearmente separáveis
Complexidade de modelos: trade-off entre flexibilidade e generalização

Referências que valem a pena

Tomando decisões com confiança calibrada: o poder das previsões probabilísticas do GPC

19/12/202531/10/2025 Por antonino

Imagine que você é um médico analisando exames médicos. Um paciente tem sintomas que poderiam indicar duas condições diferentes. Em vez de dar um diagnóstico definitivo baseado em informações incompletas, você diz: “Há 75% de chance de ser a condição A, e 25% de ser a condição B.” Esta nuance é exatamente o que as previsões probabilísticas do GPC oferecem – não apenas uma resposta, mas uma medida calibrada de quão confiante é essa resposta. Diferentemente de classificadores que forçam uma decisão binária, o GPC admite quando está em território incerto.

Como isso funciona na prática?

As previsões probabilísticas do GPC vão beyond do simples “sim/não” ao fornecer probabilidades bem calibradas para cada classe. O modelo primeiro aprende uma função latente \(f(x)\) que representa o “score” não observado para cada classe. Posteriormente, esta função é mapeada para probabilidades usando uma função de ligação como a sigmoide \(\sigma(f(x)) = \frac{1}{1 + e^{-f(x)}}\). O que torna o GPC especial é que ele não apenas fornece uma probabilidade pontual, mas considera toda a distribuição possível da função latente, resultando em probabilidades que honestamente refletem a incerteza do modelo.

Mãos na massa: diagnóstico médico com probabilidades calibradas

"""
Previsões probabilísticas com GPC para diagnóstico médico
Demonstra como obter e interpretar probabilidades calibradas
"""

import numpy as np
import matplotlib.pyplot as plt
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.calibration import calibration_curve
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier

# Simulando dados de diagnóstico médico
# Características: [idade, pressão_arterial, colesterol, glicose]
def criar_dados_medicos():
    """Cria dados simulados de pacientes com risco cardiovascular"""
    np.random.seed(42)
    n_pacientes = 800
    
    # Gerando características médicas realistas
    idade = np.random.normal(55, 15, n_pacientes)
    pressao = np.random.normal(130, 20, n_pacientes)
    colesterol = np.random.normal(200, 40, n_pacientes)
    glicose = np.random.normal(110, 25, n_pacientes)
    
    X = np.column_stack([idade, pressao, colesterol, glicose])
    
    # Risco cardiovascular baseado em combinação não-linear
    # Pacientes com múltiplos fatores de risco têm maior probabilidade
    risco_latente = (
        0.02 * (idade - 50) + 
        0.01 * (pressao - 120) + 
        0.005 * (colesterol - 180) +
        0.008 * (glicose - 100) +
        0.0001 * (idade - 50) * (pressao - 120)  # Interação
    )
    
    # Adicionando ruído e convertendo para binário
    probabilidade_risco = 1 / (1 + np.exp(-risco_latente + np.random.normal(0, 0.3, n_pacientes)))
    y = (probabilidade_risco > 0.5).astype(int)
    
    return X, y

X, y = criar_dados_medicos()

print(f"Dados médicos simulados: {X.shape[0]} pacientes")
print(f"Distribuição: {np.sum(y==1)} com risco, {np.sum(y==0)} sem risco")

# Dividindo os dados
X_treino, X_teste, y_treino, y_teste = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# Criando GPC com kernel RBF
kernel = 1.0 * RBF(length_scale=1.0)
gpc = GaussianProcessClassifier(
    kernel=kernel,
    random_state=42,
    n_restarts_optimizer=5
)

print("\nTreinando GPC para diagnóstico probabilístico...")
gpc.fit(X_treino, y_treino)

# Obtendo previsões probabilísticas
probabilidades_gpc = gpc.predict_proba(X_teste)[:, 1]  # Probabilidade de risco

print("\n=== ANÁLISE DAS PREVISÕES PROBABILÍSTICAS ===")

# Analisando casos específicos
print("\nExemplos de diagnósticos probabilísticos:")
indices_exemplo = [0, 5, 10, 15, 20]
for idx in indices_exemplo:
    prob = probabilidades_gpc[idx]
    diagnostico_real = "RISCO" if y_teste[idx] == 1 else "SEM RISCO"
    confianca_gpc = max(prob, 1-prob)
    
    print(f"Paciente {idx+1}:")
    print(f"  Probabilidade de risco: {prob:.3f} ({prob*100:.1f}%)")
    print(f"  Diagnóstico GPC: {'RISCO' if prob > 0.5 else 'SEM RISCO'}")
    print(f"  Diagnóstico real: {diagnostico_real}")
    print(f"  Confiança do modelo: {confianca_gpc:.3f}")
    print(f"  Status: {'✓ CORRETO' if (prob > 0.5) == (y_teste[idx] == 1) else '✗ ERRADO'}")

# Comparando com outros classificadores
print("\n=== COMPARAÇÃO COM OUTROS MÉTODOS ===")

# Regressão Logística
lr = LogisticRegression(random_state=42)
lr.fit(X_treino, y_treino)
prob_lr = lr.predict_proba(X_teste)[:, 1]

# Random Forest
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_treino, y_treino)
prob_rf = rf.predict_proba(X_teste)[:, 1]

# Análise de calibração
def plot_calibracao(y_true, probs, labels):
    """Plota curvas de calibração para diferentes modelos"""
    plt.figure(figsize=(10, 8))
    
    for i, (prob, label) in enumerate(zip(probs, labels)):
        fraction_of_positives, mean_predicted_value = calibration_curve(
            y_true, prob, n_bins=10, strategy='quantile'
        )
        
        plt.subplot(2, 1, 1)
        plt.plot(mean_predicted_value, fraction_of_positives, "s-", 
                label=label, alpha=0.8)
        
        plt.subplot(2, 1, 2)
        plt.hist(prob, bins=20, alpha=0.6, label=label, density=True)
    
    plt.subplot(2, 1, 1)
    plt.plot([0, 1], [0, 1], "k--", label="Perfeitamente calibrado")
    plt.xlabel("Probabilidade Prevista")
    plt.ylabel("Fração de Positivos")
    plt.title("Curvas de Calibração")
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    plt.subplot(2, 1, 2)
    plt.xlabel("Probabilidade Prevista")
    plt.ylabel("Densidade")
    plt.title("Distribuição das Probabilidades")
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()

# Plotando comparação
probabilidades = [probabilidades_gpc, prob_lr, prob_rf]
labels = ['GPC', 'Regressão Logística', 'Random Forest']
plot_calibracao(y_teste, probabilidades, labels)

# Análise de casos de fronteira (alta incerteza)
print("\n=== CASOS DE FRONTEIRA (ALTA INCERTEZA) ===")
casos_incertos = (probabilidades_gpc > 0.4) & (probabilidades_gpc < 0.6)
print(f"Pacientes com diagnóstico incerto (40%-60% probabilidade): {np.sum(casos_incertos)}")

if np.any(casos_incertos):
    print("Estes casos podem precisar de exames adicionais:")
    for idx in np.where(casos_incertos)[0][:3]:
        print(f"  Paciente {idx}: probabilidade = {probabilidades_gpc[idx]:.3f}")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

"""

Previsões probabilísticas com GPC para diagnóstico médico

Demonstra como obter e interpretar probabilidades calibradas

"""

import numpy as np

import matplotlib.pyplot as plt

from sklearn.gaussian_process import GaussianProcessClassifier

from sklearn.gaussian_process.kernels import RBF

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

from sklearn.calibration import calibration_curve

from sklearn.linear_model import LogisticRegression

from sklearn.ensemble import RandomForestClassifier

# Simulando dados de diagnóstico médico

# Características: [idade, pressão_arterial, colesterol, glicose]

def criar_dados_medicos():

"""Cria dados simulados de pacientes com risco cardiovascular"""

np.random.seed(42)

n_pacientes = 800

# Gerando características médicas realistas

idade = np.random.normal(55, 15, n_pacientes)

pressao = np.random.normal(130, 20, n_pacientes)

colesterol = np.random.normal(200, 40, n_pacientes)

glicose = np.random.normal(110, 25, n_pacientes)

X = np.column_stack([idade, pressao, colesterol, glicose])

# Risco cardiovascular baseado em combinação não-linear

# Pacientes com múltiplos fatores de risco têm maior probabilidade

risco_latente = (

0.02 * (idade - 50) +

0.01 * (pressao - 120) +

0.005 * (colesterol - 180) +

0.008 * (glicose - 100) +

0.0001 * (idade - 50) * (pressao - 120) # Interação

)

# Adicionando ruído e convertendo para binário

probabilidade_risco = 1 / (1 + np.exp(-risco_latente + np.random.normal(0, 0.3, n_pacientes)))

y = (probabilidade_risco > 0.5).astype(int)

return X, y

X, y = criar_dados_medicos()

print(f"Dados médicos simulados: {X.shape[0]} pacientes")

print(f"Distribuição: {np.sum(y==1)} com risco, {np.sum(y==0)} sem risco")

# Dividindo os dados

X_treino, X_teste, y_treino, y_teste = train_test_split(

X, y, test_size=0.3, random_state=42, stratify=y

)

# Criando GPC com kernel RBF

kernel = 1.0 * RBF(length_scale=1.0)

gpc = GaussianProcessClassifier(

kernel=kernel,

random_state=42,

n_restarts_optimizer=5

)

print("\nTreinando GPC para diagnóstico probabilístico...")

gpc.fit(X_treino, y_treino)

# Obtendo previsões probabilísticas

probabilidades_gpc = gpc.predict_proba(X_teste)[:, 1] # Probabilidade de risco

print("\n=== ANÁLISE DAS PREVISÕES PROBABILÍSTICAS ===")

# Analisando casos específicos

print("\nExemplos de diagnósticos probabilísticos:")

indices_exemplo = [0, 5, 10, 15, 20]

for idx in indices_exemplo:

prob = probabilidades_gpc[idx]

diagnostico_real = "RISCO" if y_teste[idx] == 1 else "SEM RISCO"

confianca_gpc = max(prob, 1-prob)

print(f"Paciente {idx+1}:")

print(f" Probabilidade de risco: {prob:.3f} ({prob*100:.1f}%)")

print(f" Diagnóstico GPC: {'RISCO' if prob > 0.5 else 'SEM RISCO'}")

print(f" Diagnóstico real: {diagnostico_real}")

print(f" Confiança do modelo: {confianca_gpc:.3f}")

print(f" Status: {'✓ CORRETO' if (prob > 0.5) == (y_teste[idx] == 1) else '✗ ERRADO'}")

# Comparando com outros classificadores

print("\n=== COMPARAÇÃO COM OUTROS MÉTODOS ===")

# Regressão Logística

lr = LogisticRegression(random_state=42)

lr.fit(X_treino, y_treino)

prob_lr = lr.predict_proba(X_teste)[:, 1]

# Random Forest

rf = RandomForestClassifier(n_estimators=100, random_state=42)

rf.fit(X_treino, y_treino)

prob_rf = rf.predict_proba(X_teste)[:, 1]

# Análise de calibração

def plot_calibracao(y_true, probs, labels):

"""Plota curvas de calibração para diferentes modelos"""

plt.figure(figsize=(10, 8))

for i, (prob, label) in enumerate(zip(probs, labels)):

fraction_of_positives, mean_predicted_value = calibration_curve(

y_true, prob, n_bins=10, strategy='quantile'

)

plt.subplot(2, 1, 1)

plt.plot(mean_predicted_value, fraction_of_positives, "s-",

label=label, alpha=0.8)

plt.subplot(2, 1, 2)

plt.hist(prob, bins=20, alpha=0.6, label=label, density=True)

plt.subplot(2, 1, 1)

plt.plot([0, 1], [0, 1], "k--", label="Perfeitamente calibrado")

plt.xlabel("Probabilidade Prevista")

plt.ylabel("Fração de Positivos")

plt.title("Curvas de Calibração")

plt.legend()

plt.grid(True, alpha=0.3)

plt.subplot(2, 1, 2)

plt.xlabel("Probabilidade Prevista")

plt.ylabel("Densidade")

plt.title("Distribuição das Probabilidades")

plt.legend()

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# Plotando comparação

probabilidades = [probabilidades_gpc, prob_lr, prob_rf]

labels = ['GPC', 'Regressão Logística', 'Random Forest']

plot_calibracao(y_teste, probabilidades, labels)

# Análise de casos de fronteira (alta incerteza)

print("\n=== CASOS DE FRONTEIRA (ALTA INCERTEZA) ===")

casos_incertos = (probabilidades_gpc > 0.4) & (probabilidades_gpc < 0.6)

print(f"Pacientes com diagnóstico incerto (40%-60% probabilidade): {np.sum(casos_incertos)}")

if np.any(casos_incertos):

print("Estes casos podem precisar de exames adicionais:")

for idx in np.where(casos_incertos)[0][:3]:

print(f" Paciente {idx}: probabilidade = {probabilidades_gpc[idx]:.3f}")

Os detalhes que fazem diferença

A grande vantagem das previsões probabilísticas do GPC é sua calibração natural – quando o modelo diz “75% de chance”, isso realmente significa que em 75 de 100 casos similares a previsão estaria correta. Contudo, esta calibração depende crucialmente da escolha adequada do kernel e da qualidade dos dados de treinamento. Analogamente importante é entender que as probabilidades do GPC refletem incerteza epistêmica (devido à falta de dados) mas não necessariamente incerteza aleatória inerente ao processo. A aproximação por Laplace usada no Scikit-Learn torna o método computacionalmente viável, mas pode subestimar incertezas em problemas muito complexos.

Calibração: Probabilidades do GPC são naturalmente bem calibradas
Incerteza epistêmica: Reflete falta de conhecimento, não variabilidade inerente
Casos de fronteira: Probabilidades perto de 0.5 indicam necessidade de mais informações
Tomada de decisão: Use probabilidades para decisões baseadas em risco

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Como saber se as probabilidades do GPC são confiáveis?” Excelente questão! A curva de calibração é sua melhor ferramenta – ela mostra se probabilidades previstas correspondem a frequências observadas. Uma confusão comum é entre a “confiança” de modelos como SVM e as probabilidades do GPC – as primeiras não são probabilidades calibradas. Outra dúvida frequente: “Quando devo confiar em uma probabilidade de 60% versus 90%?” Use limiares de decisão baseados no custo de erros – em medicina, talvez queira 90% de certeza, enquanto em recomendação de filmes 60% pode ser suficiente.

Para onde ir agora?

Experimente usar as previsões probabilísticas do GPC em problemas onde diferentes tipos de erro têm custos diferentes. Implemente sistemas de decisão que usem limiares de probabilidade adaptativos. Compare a calibração do GPC com outros métodos em seus próprios dados. O momento “aha!” acontece quando você percebe que tomar decisões considerando não apenas o que é mais provável, mas quão provável é, leva a resultados muito melhores no mundo real.

Assuntos relacionados

Para dominar previsões probabilísticas, estude:

Teoria da decisão: custos de falsos positivos vs falsos negativos
Calibração de modelos: como avaliar e melhorar probabilidades
Incerteza epistêmica vs aleatória: fontes diferentes de incerteza
Curvas ROC e precisão-recall: avaliação de classificadores probabilísticos
Teoria da informação: entropia e surpresa em previsões