antonino, Autor em Área de Trampo

Identificando flores com confiança: como o GPC classifica espécies de íris com precisão probabilística

19/12/202531/10/2025 Por antonino

Imagine que você é um botânico iniciante tentando identificar espécies de íris em um jardim. Você mede cuidadosamente as pétalas e sépalas, mas algumas flores parecem estar no limite entre duas espécies. Em vez de fazer um palpite, você gostaria de saber: “Qual a probabilidade de esta ser uma íris setosa versus virginica?” O Gaussian Process Classifier (GPC) no dataset Iris faz exatamente isso – ele não apenas classifica, mas fornece probabilidades calibradas que refletem o quão confiante é cada identificação, especialmente para aquelas flores que desafiam categorização simples.

Como isso funciona na prática?

O dataset Iris é o “Hello World” da classificação multiclasse, contendo três espécies de íris com quatro medidas cada. Enquanto a maioria dos classificadores fornece apenas um label, o GPC oferece uma abordagem probabilística sofisticada. Ele modela funções latentes separadas para cada classe e usa uma aproximação one-vs-one para problemas multiclasse. Diferentemente de métodos que apenas maximizam acurácia, o GPC captura a incerteza inerente aos dados, mostrando onde as fronteiras entre espécies são nebulosas e onde são bem definidas. Esta nuance é particularmente valiosa em problemas do mundo real onde decisões erradas têm custos.

Mãos na massa: classificando íris com probabilidades

"""
Classificação de espécies de Íris usando Gaussian Process Classifier
Demonstra classificação multiclasse com quantificação de incerteza
"""

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns

# Carregando o dataset Iris
iris = load_iris()
X, y = iris.data, iris.target
nomes_classes = iris.target_names
nomes_caracteristicas = iris.feature_names

print("=== DATASET IRIS ===")
print(f"Forma dos dados: {X.shape}")
print(f"Classes: {list(nomes_classes)}")
print(f"Características: {list(nomes_caracteristicas)}")
print(f"Distribuição das classes: {np.bincount(y)}")

# Pré-processamento: normalização é importante para GPC
scaler = StandardScaler()
X_normalizado = scaler.fit_transform(X)

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

print(f"\nDivisão treino/teste: {X_treino.shape[0]} para treino, {X_teste.shape[0]} para teste")

# Criando e treinando o GPC
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 = gpc.score(X_teste, y_teste)
print(f"\nAcurácia no conjunto de teste: {acuracia:.3f}")

# Análise detalhada das previsões
print("\n=== ANÁLISE DAS PREVISÕES PROBABILÍSTICAS ===")
print("Exemplos de classificações com probabilidades:")

# Selecionando alguns casos interessantes para análise
indices_analise = [0, 5, 10, 15, 20]  # Alguns pontos de teste

for idx in indices_analise:
    probabilidades = y_prob[idx]
    classe_predita = y_pred[idx]
    classe_real = y_teste[idx]
    
    print(f"\nFlor {idx+1}:")
    print(f"  Classe real: {nomes_classes[classe_real]}")
    print(f"  Classe prevista: {nomes_classes[classe_predita]}")
    print(f"  Probabilidades: {dict(zip(nomes_classes, probabilidades))}")
    
    confianca = np.max(probabilidades)
    classe_mais_provavel = np.argmax(probabilidades)
    
    print(f"  Confiança: {confianca:.3f}")
    print(f"  Status: {'✓ CORRETO' if classe_predita == classe_real else '✗ ERRADO'}")

# Identificando casos de alta incerteza
incertezas = 1 - np.max(y_prob, axis=1)
casos_incertos = incertezas > 0.3  # Limite arbitrário para alta incerteza

print(f"\nCasos com alta incerteza (>30%): {np.sum(casos_incertos)} flores")
if np.any(casos_incertos):
    print("Estas flores estão próximas das fronteiras entre espécies:")
    for idx in np.where(casos_incertos)[0][:3]:  # Mostra os 3 primeiros
        probs = y_prob[idx]
        print(f"  Flor {idx}: {dict(zip(nomes_classes, probs))}")

# Visualização das fronteiras de decisão (em 2D para visualização)
def visualizar_fronteiras_2d():
    """Visualiza fronteiras de decisão usando as 2 características mais importantes"""
    # Usando comprimento da pétala e largura da pétala (as mais discriminativas)
    X_2d = X_normalizado[:, [2, 3]]  # petal length, petal width
    
    # Treinando GPC apenas com 2 características para visualização
    gpc_2d = GaussianProcessClassifier(kernel=kernel, random_state=42)
    gpc_2d.fit(X_2d, y)
    
    # Criando grid para visualização
    x_min, x_max = X_2d[:, 0].min() - 1, X_2d[:, 0].max() + 1
    y_min, y_max = X_2d[:, 1].min() - 1, X_2d[:, 1].max() + 1
    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),
                         np.linspace(y_min, y_max, 100))
    
    # Previsões no grid
    Z = gpc_2d.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    
    # Probabilidades no grid
    Z_prob = gpc_2d.predict_proba(np.c_[xx.ravel(), yy.ravel()])
    Z_confidence = np.max(Z_prob, axis=1).reshape(xx.shape)
    Z_uncertainty = 1 - Z_confidence
    
    # Plot
    fig, axes = plt.subplots(1, 3, figsize=(18, 5))
    
    # Plot 1: Fronteiras de decisão
    contour1 = axes[0].contourf(xx, yy, Z, alpha=0.6, cmap='Set3')
    scatter1 = axes[0].scatter(X_2d[:, 0], X_2d[:, 1], c=y, cmap='Set3', 
                              edgecolors='black', s=50)
    axes[0].set_xlabel('Comprimento da Pétala (normalizado)')
    axes[0].set_ylabel('Largura da Pétala (normalizado)')
    axes[0].set_title('Fronteiras de Decisão do GPC\nDataset Iris')
    plt.colorbar(scatter1, ax=axes[0])
    
    # Plot 2: Confiança das previsões
    contour2 = axes[1].contourf(xx, yy, Z_confidence, levels=20, alpha=0.6, cmap='viridis')
    axes[1].scatter(X_2d[:, 0], X_2d[:, 1], c=y, cmap='Set3', 
                   edgecolors='black', s=50)
    axes[1].set_xlabel('Comprimento da Pétala (normalizado)')
    axes[1].set_ylabel('Largura da Pétala (normalizado)')
    axes[1].set_title('Mapa de Confiança do GPC')
    plt.colorbar(contour2, ax=axes[1])
    
    # Plot 3: Incerteza
    contour3 = axes[2].contourf(xx, yy, Z_uncertainty, levels=20, alpha=0.6, cmap='hot_r')
    axes[2].scatter(X_2d[:, 0], X_2d[:, 1], c=y, cmap='Set3', 
                   edgecolors='black', s=50)
    axes[2].set_xlabel('Comprimento da Pétala (normalizado)')
    axes[2].set_ylabel('Largura da Pétala (normalizado)')
    axes[2].set_title('Mapa de Incerteza do GPC\n(Áreas de fronteira)')
    plt.colorbar(contour3, ax=axes[2])
    
    plt.tight_layout()
    plt.show()

visualizar_fronteiras_2d()

# Matriz de confusão
print("\n=== MATRIZ DE CONFUSÃO ===")
cm = confusion_matrix(y_teste, y_pred)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
            xticklabels=nomes_classes, yticklabels=nomes_classes)
plt.title('Matriz de Confusão - GPC no Dataset Iris')
plt.ylabel('Classe Real')
plt.xlabel('Classe Prevista')
plt.show()

print("\nRelatório de classificação:")
print(classification_report(y_teste, y_pred, target_names=nomes_classes))

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

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

"""

Classificação de espécies de Íris usando Gaussian Process Classifier

Demonstra classificação multiclasse com quantificação de incerteza

"""

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import load_iris

from sklearn.gaussian_process import GaussianProcessClassifier

from sklearn.gaussian_process.kernels import RBF

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import classification_report, confusion_matrix

import seaborn as sns

# Carregando o dataset Iris

iris = load_iris()

X, y = iris.data, iris.target

nomes_classes = iris.target_names

nomes_caracteristicas = iris.feature_names

print("=== DATASET IRIS ===")

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

print(f"Classes: {list(nomes_classes)}")

print(f"Características: {list(nomes_caracteristicas)}")

print(f"Distribuição das classes: {np.bincount(y)}")

# Pré-processamento: normalização é importante para GPC

scaler = StandardScaler()

X_normalizado = scaler.fit_transform(X)

# Dividindo em treino e teste

X_treino, X_teste, y_treino, y_teste = train_test_split(

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

)

print(f"\nDivisão treino/teste: {X_treino.shape[0]} para treino, {X_teste.shape[0]} para teste")

# Criando e treinando o GPC

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 = gpc.score(X_teste, y_teste)

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

# Análise detalhada das previsões

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

print("Exemplos de classificações com probabilidades:")

# Selecionando alguns casos interessantes para análise

indices_analise = [0, 5, 10, 15, 20] # Alguns pontos de teste

for idx in indices_analise:

probabilidades = y_prob[idx]

classe_predita = y_pred[idx]

classe_real = y_teste[idx]

print(f"\nFlor {idx+1}:")

print(f" Classe real: {nomes_classes[classe_real]}")

print(f" Classe prevista: {nomes_classes[classe_predita]}")

print(f" Probabilidades: {dict(zip(nomes_classes, probabilidades))}")

confianca = np.max(probabilidades)

classe_mais_provavel = np.argmax(probabilidades)

print(f" Confiança: {confianca:.3f}")

print(f" Status: {'✓ CORRETO' if classe_predita == classe_real else '✗ ERRADO'}")

# Identificando casos de alta incerteza

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

casos_incertos = incertezas > 0.3 # Limite arbitrário para alta incerteza

print(f"\nCasos com alta incerteza (>30%): {np.sum(casos_incertos)} flores")

if np.any(casos_incertos):

print("Estas flores estão próximas das fronteiras entre espécies:")

for idx in np.where(casos_incertos)[0][:3]: # Mostra os 3 primeiros

probs = y_prob[idx]

print(f" Flor {idx}: {dict(zip(nomes_classes, probs))}")

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

def visualizar_fronteiras_2d():

"""Visualiza fronteiras de decisão usando as 2 características mais importantes"""

# Usando comprimento da pétala e largura da pétala (as mais discriminativas)

X_2d = X_normalizado[:, [2, 3]] # petal length, petal width

# Treinando GPC apenas com 2 características para visualização

gpc_2d = GaussianProcessClassifier(kernel=kernel, random_state=42)

gpc_2d.fit(X_2d, y)

# Criando grid para visualização

x_min, x_max = X_2d[:, 0].min() - 1, X_2d[:, 0].max() + 1

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

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

np.linspace(y_min, y_max, 100))

# Previsões no grid

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

Z = Z.reshape(xx.shape)

# Probabilidades no grid

Z_prob = gpc_2d.predict_proba(np.c_[xx.ravel(), yy.ravel()])

Z_confidence = np.max(Z_prob, axis=1).reshape(xx.shape)

Z_uncertainty = 1 - Z_confidence

# Plot

fig, axes = plt.subplots(1, 3, figsize=(18, 5))

# Plot 1: Fronteiras de decisão

contour1 = axes[0].contourf(xx, yy, Z, alpha=0.6, cmap='Set3')

scatter1 = axes[0].scatter(X_2d[:, 0], X_2d[:, 1], c=y, cmap='Set3',

edgecolors='black', s=50)

axes[0].set_xlabel('Comprimento da Pétala (normalizado)')

axes[0].set_ylabel('Largura da Pétala (normalizado)')

axes[0].set_title('Fronteiras de Decisão do GPC\nDataset Iris')

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

# Plot 2: Confiança das previsões

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

axes[1].scatter(X_2d[:, 0], X_2d[:, 1], c=y, cmap='Set3',

edgecolors='black', s=50)

axes[1].set_xlabel('Comprimento da Pétala (normalizado)')

axes[1].set_ylabel('Largura da Pétala (normalizado)')

axes[1].set_title('Mapa de Confiança do GPC')

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

# Plot 3: Incerteza

contour3 = axes[2].contourf(xx, yy, Z_uncertainty, levels=20, alpha=0.6, cmap='hot_r')

axes[2].scatter(X_2d[:, 0], X_2d[:, 1], c=y, cmap='Set3',

edgecolors='black', s=50)

axes[2].set_xlabel('Comprimento da Pétala (normalizado)')

axes[2].set_ylabel('Largura da Pétala (normalizado)')

axes[2].set_title('Mapa de Incerteza do GPC\n(Áreas de fronteira)')

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

plt.tight_layout()

plt.show()

visualizar_fronteiras_2d()

# Matriz de confusão

print("\n=== MATRIZ DE CONFUSÃO ===")

cm = confusion_matrix(y_teste, y_pred)

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

sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',

xticklabels=nomes_classes, yticklabels=nomes_classes)

plt.title('Matriz de Confusão - GPC no Dataset Iris')

plt.ylabel('Classe Real')

plt.xlabel('Classe Prevista')

plt.show()

print("\nRelatório de classificação:")

print(classification_report(y_teste, y_pred, target_names=nomes_classes))

Os detalhes que fazem diferença

O GPC no dataset Iris revela insights importantes sobre a natureza probabilística da classificação. A espécie setosa é facilmente separável das outras, resultando em probabilidades próximas de 1.0 quando corretamente classificada. Contudo, as espécies versicolor e virginica se sobrepõem significativamente, criando regiões de alta incerteza onde o GPC honestamente fornece probabilidades mais balanceadas. Esta transparência é valiosa em aplicações reais onde saber o “quão certo” o modelo está pode ser tão importante quanto a classificação em si. A normalização dos dados é particularmente crucial para o GPC, pois características em escalas diferentes podem distorcer as medidas de similaridade do kernel.

Normalização obrigatória: Características em escalas diferentes prejudicam o kernel RBF
Incerteza informativa: Áreas de alta incerteza correspondem a regiões de sobreposição real entre classes
Abordagem one-vs-one: O GPC usa esta estratégia para problemas multiclasse
Interpretabilidade: Probabilidades refletem a estrutura subjacente dos dados

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Por que usar GPC no Iris se outros métodos mais simples também funcionam?” Excelente questão! Enquanto métodos como KNN ou árvores de decisão podem ter acurácia similar, o GPC fornece probabilidades calibradas que são valiosas para aplicações onde você precisa entender não apenas o “o quê” mas o “quão confiante”. Uma confusão comum é pensar que alta incerteza significa que o modelo é ruim – na verdade, ela indica honestidade sobre limites do conhecimento. Outra dúvida frequente: “Como o GPC lida com três classes?” Ele treina classificadores binários para cada par de classes e combina os resultados.

Para onde ir agora?

Experimente o GPC em outros datasets de classificação multiclasse e observe como as probabilidades se comportam em diferentes estruturas de dados. Tente diferentes kernels e observe como afetam as fronteiras de decisão. Use as informações de incerteza para identificar onde coletar mais dados. O momento “aha!” acontece quando você percebe que a incerteza quantificada pelo GPC não é um bug, mas uma feature valiosa que reflete a complexidade inerente dos dados reais.

Assuntos relacionados

Para aprofundar seu entendimento, estude:

Classificação multiclasse: estratégias one-vs-one e one-vs-rest
Normalização de dados: importância para métodos baseados em distância
Análise discriminante: fundamentos teóricos da separação entre classes
Calibração de probabilidades: como avaliar se probabilidades são realistas
Visualização de dados multidimensionais: técnicas para entender estruturas complexas

Referências que valem a pena

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