antonino, Autor em Área de Trampo

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

Referências que valem a pena

Navegando por decisões incertas: como a classificação por processos gaussianos mapeia fronteiras probabilísticas

19/12/202531/10/2025 Por antonino

Imagine que você está tentando encontrar a saída em um labirinto complexo. Em cada bifurcação, você não tem certeza absoluta sobre qual caminho levará à saída, mas pode fazer estimativas baseadas em pistas visuais e sua experiência anterior. A Classificação por Processos Gaussianos (GPC) funciona de maneira similar – em vez de simplesmente dizer “vire à esquerda” ou “vire à direita”, ela fornece probabilidades: “há 70% de chance que a esquerda leve à saída, mas ainda há 30% de chance de que a direita seja melhor”. Esta nuance probabilística torna o GPC especialmente valioso para decisões onde a incerteza importa.

Como isso funciona na prática?

O GPC estende a ideia dos processos gaussianos para problemas de classificação através de uma abordagem bayesiana elegante. Enquanto classificadores tradicionais como SVM ou Random Forest fornecem apenas labels definitivos, o GPC modela uma função latente que é mapeada para probabilidades via uma função de ligação (como a sigmoide). Diferentemente da regressão gaussiana que modela valores contínuos diretamente, o GPC primeiro modela uma função contínua subjacente e depois a transforma em probabilidades de classe. Esta abordagem permite não apenas classificar, mas quantificar o quão confiante é cada classificação, revelando áreas de fronteira onde o modelo tem dúvidas.

Mãos na massa: classificando caminhos em um labirinto virtual

"""
Classificação por Processos Gaussianos para navegação em labirinto
Demonstra classificação probabilística com quantificação de incerteza
"""

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.metrics import accuracy_score, confusion_matrix

# Criando dados simulados de um labirinto
# Características: [distância_parede_esquerda, distância_parede_direita, ângulo_corredor]
def criar_dados_labirinto():
    """Simula dados de navegação em labirinto com fronteiras complexas"""
    np.random.seed(42)
    n_amostras = 500
    
    # Gerando características de posição no labirinto
    X = np.random.uniform(0, 10, (n_amostras, 3))
    
    # Criando fronteira de decisão não-linear complexa
    # Caminhos que levam à saída seguem um padrão sinusoidal
    def eh_caminho_correto(x1, x2, x3):
        return (np.sin(x1 * 0.8) + np.cos(x2 * 0.6) + x3 * 0.1) > 0.5
    
    y = np.array([eh_caminho_correto(x[0], x[1], x[2]) for x in X])
    
    return X, y

X, y = criar_dados_labirinto()

print(f"Dados do labirinto criados: {X.shape[0]} posições")
print(f"Distribuição de classes: {np.sum(y==1)} caminhos corretos, {np.sum(y==0)} caminhos errados")

# Dividindo em treino e teste
X_treino, X_teste, y_treino, y_teste = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# Criando o classificador por processo gaussiano
kernel = 1.0 * RBF(length_scale=1.0)
gpc = GaussianProcessClassifier(
    kernel=kernel,
    random_state=42,
    n_restarts_optimizer=5
)

print("\nTreinando GPC...")
gpc.fit(X_treino, y_treino)

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

# Fazendo previsões probabilísticas
y_pred = gpc.predict(X_teste)
y_prob = gpc.predict_proba(X_teste)

# Avaliando o modelo
acuracia = accuracy_score(y_teste, y_pred)
print(f"\nAcurácia no conjunto de teste: {acuracia:.3f}")

# Analisando as probabilidades
print("\nExemplo de previsões probabilísticas:")
for i in range(5):
    prob_classe_1 = y_prob[i, 1]
    decisao = "CORRETO" if y_pred[i] == 1 else "ERRADO"
    confianca = max(y_prob[i])
    print(f"Posição {i+1}: {decisao} (confiança: {confianca:.3f})")

# Visualizando fronteiras de decisão (em 2D para visualização)
def visualizar_fronteiras():
    """Visualiza as fronteiras de decisão em 2 dimensões"""
    # Criando grid para visualização
    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max, 50),
                          np.linspace(x2_min, x2_max, 50))
    
    # Usando valor médio para terceira dimensão
    x3_medio = np.mean(X[:, 2])
    X_grid = np.c_[xx1.ravel(), xx2.ravel(), np.full(xx1.ravel().shape, x3_medio)]
    
    # Previsões do GPC
    Z = gpc.predict_proba(X_grid)[:, 1]
    Z = Z.reshape(xx1.shape)
    
    plt.figure(figsize=(12, 5))
    
    # Plot das probabilidades
    plt.subplot(1, 2, 1)
    contour = plt.contourf(xx1, xx2, Z, levels=20, alpha=0.8, cmap='RdYlBu')
    plt.colorbar(contour, label='Probabilidade caminho correto')
    plt.scatter(X_treino[:, 0], X_treino[:, 1], c=y_treino, 
               cmap='RdYlBu', edgecolors='black', s=30)
    plt.xlabel('Distância parede esquerda')
    plt.ylabel('Distância parede direita')
    plt.title('Fronteiras de Decisão do GPC\n(Probabilidades)')
    
    # Plot das regiões de incerteza
    plt.subplot(1, 2, 2)
    # Incerteza é máxima quando probabilidade está perto de 0.5
    incerteza = 1 - 2 * np.abs(Z - 0.5)
    contour = plt.contourf(xx1, xx2, incerteza, levels=20, alpha=0.8, cmap='viridis')
    plt.colorbar(contour, label='Nível de incerteza')
    plt.scatter(X_treino[:, 0], X_treino[:, 1], c=y_treino, 
               cmap='RdYlBu', edgecolors='black', s=30)
    plt.xlabel('Distância parede esquerda')
    plt.ylabel('Distância parede direita')
    plt.title('Mapa de Incerteza do GPC')
    
    plt.tight_layout()
    plt.show()

visualizar_fronteiras()

# Análise de casos difíceis (alta incerteza)
probabilidades_teste = gpc.predict_proba(X_teste)
incertezas = 1 - np.max(probabilidades_teste, axis=1)

print(f"\nCasos com alta incerteza (probabilidade próxima de 0.5):")
casos_dificeis = incertezas > 0.4
print(f"{np.sum(casos_dificeis)} casos onde o modelo tem baixa confiança")

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

"""

Classificação por Processos Gaussianos para navegação em labirinto

Demonstra classificação probabilística com quantificação de incerteza

"""

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.metrics import accuracy_score, confusion_matrix

# Criando dados simulados de um labirinto

# Características: [distância_parede_esquerda, distância_parede_direita, ângulo_corredor]

def criar_dados_labirinto():

"""Simula dados de navegação em labirinto com fronteiras complexas"""

np.random.seed(42)

n_amostras = 500

# Gerando características de posição no labirinto

X = np.random.uniform(0, 10, (n_amostras, 3))

# Criando fronteira de decisão não-linear complexa

# Caminhos que levam à saída seguem um padrão sinusoidal

def eh_caminho_correto(x1, x2, x3):

return (np.sin(x1 * 0.8) + np.cos(x2 * 0.6) + x3 * 0.1) > 0.5

y = np.array([eh_caminho_correto(x[0], x[1], x[2]) for x in X])

return X, y

X, y = criar_dados_labirinto()

print(f"Dados do labirinto criados: {X.shape[0]} posições")

print(f"Distribuição de classes: {np.sum(y==1)} caminhos corretos, {np.sum(y==0)} caminhos errados")

# Dividindo em treino e teste

X_treino, X_teste, y_treino, y_teste = train_test_split(

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

)

# Criando o classificador por processo gaussiano

kernel = 1.0 * RBF(length_scale=1.0)

gpc = GaussianProcessClassifier(

kernel=kernel,

random_state=42,

n_restarts_optimizer=5

)

print("\nTreinando GPC...")

gpc.fit(X_treino, y_treino)

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

# Fazendo previsões probabilísticas

y_pred = gpc.predict(X_teste)

y_prob = gpc.predict_proba(X_teste)

# Avaliando o modelo

acuracia = accuracy_score(y_teste, y_pred)

print(f"\nAcurácia no conjunto de teste: {acuracia:.3f}")

# Analisando as probabilidades

print("\nExemplo de previsões probabilísticas:")

for i in range(5):

prob_classe_1 = y_prob[i, 1]

decisao = "CORRETO" if y_pred[i] == 1 else "ERRADO"

confianca = max(y_prob[i])

print(f"Posição {i+1}: {decisao} (confiança: {confianca:.3f})")

# Visualizando fronteiras de decisão (em 2D para visualização)

def visualizar_fronteiras():

"""Visualiza as fronteiras de decisão em 2 dimensões"""

# Criando grid para visualização

x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1

x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1

xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max, 50),

np.linspace(x2_min, x2_max, 50))

# Usando valor médio para terceira dimensão

x3_medio = np.mean(X[:, 2])

X_grid = np.c_[xx1.ravel(), xx2.ravel(), np.full(xx1.ravel().shape, x3_medio)]

# Previsões do GPC

Z = gpc.predict_proba(X_grid)[:, 1]

Z = Z.reshape(xx1.shape)

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

# Plot das probabilidades

plt.subplot(1, 2, 1)

contour = plt.contourf(xx1, xx2, Z, levels=20, alpha=0.8, cmap='RdYlBu')

plt.colorbar(contour, label='Probabilidade caminho correto')

plt.scatter(X_treino[:, 0], X_treino[:, 1], c=y_treino,

cmap='RdYlBu', edgecolors='black', s=30)

plt.xlabel('Distância parede esquerda')

plt.ylabel('Distância parede direita')

plt.title('Fronteiras de Decisão do GPC\n(Probabilidades)')

# Plot das regiões de incerteza

plt.subplot(1, 2, 2)

# Incerteza é máxima quando probabilidade está perto de 0.5

incerteza = 1 - 2 * np.abs(Z - 0.5)

contour = plt.contourf(xx1, xx2, incerteza, levels=20, alpha=0.8, cmap='viridis')

plt.colorbar(contour, label='Nível de incerteza')

plt.scatter(X_treino[:, 0], X_treino[:, 1], c=y_treino,

cmap='RdYlBu', edgecolors='black', s=30)

plt.xlabel('Distância parede esquerda')

plt.ylabel('Distância parede direita')

plt.title('Mapa de Incerteza do GPC')

plt.tight_layout()

plt.show()

visualizar_fronteiras()

# Análise de casos difíceis (alta incerteza)

probabilidades_teste = gpc.predict_proba(X_teste)

incertezas = 1 - np.max(probabilidades_teste, axis=1)

print(f"\nCasos com alta incerteza (probabilidade próxima de 0.5):")

casos_dificeis = incertezas > 0.4

print(f"{np.sum(casos_dificeis)} casos onde o modelo tem baixa confiança")

Os detalhes que fazem diferença

A grande vantagem do GPC sobre classificadores tradicionais é sua capacidade natural de quantificar incerteza. Enquanto métodos como SVM fornecem apenas uma decisão binária, o GPC fornece probabilidades calibradas que refletem verdadeiramente a confiança do modelo. Contudo, esta sofisticação vem com custos computacionais significativos (\(O(n^3)\) para treinamento), tornando-o impraticável para conjuntos muito grandes. Analogamente importante é a escolha do kernel – o RBF padrão funciona bem para muitos problemas, mas kernels específicos podem capturar melhor a estrutura dos dados. A aproximação por Laplace usada no Scikit-Learn torna o método computacionalmente viável, mas introduz algumas limitações em problemas muito complexos.

Vantagem principal: Probabilidades calibradas e quantificação de incerteza
Limitação prática: Complexidade computacional limita uso a datasets médios
Kernel recomendado: RBF para problemas gerais, kernels customizados para domínios específicos
Melhor uso: Problemas com dados limitados mas onde incerteza é importante

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Quando devo usar GPC em vez de outros classificadores?” Excelente questão! Use GPC quando a quantificação da incerteza for crucial para sua aplicação, quando você tiver dados limitados mas de alta qualidade, ou quando precisar de probabilidades bem calibradas. Uma confusão comum é entre a probabilidade fornecida pelo GPC e a “confiança” de outros modelos – as probabilidades do GPC são fundamentadas em teoria probabilística sólida. Outra dúvida frequente: “O GPC funciona para multiclasse?” Sim! O Scikit-Learn implementa uma abordagem “um-contra-um” para problemas com mais de duas classes.

Para onde ir agora?

Experimente o GPC em problemas onde a incerteza importa, como diagnóstico médico, detecção de fraudes ou qualquer aplicação onde decisões erradas tenham custos altos. Compare as probabilidades do GPC com outros métodos como Random Forest ou Regressão Logística. Preste atenção especial às áreas onde o modelo tem alta incerteza – elas podem indicar onde coletar mais dados. O momento “aha!” acontece quando você percebe que tomar decisões considerando a incerteza pode ser mais inteligente que seguir cegamente previsões pontuais.

Assuntos relacionados

Para dominar o GPC, estude estes conceitos:

Inferência bayesiana: atualização de crenças com dados
Funções de ligação: mapeamento de funções latentes para probabilidades
Teoria de decisão: tomada de decisão sob incerteza
Calibração de probabilidades: como avaliar se probabilidades são realistas
Processos gaussianos: fundamentos da abordagem