Arquivo de scikit-learn - Área de Trampo

A arte de medir similaridades: como os núcleos definem a personalidade dos processos gaussianos

19/12/202531/10/2025 Por antonino

Imagine que você está organizando uma biblioteca e precisa decidir como agrupar livros similares. Você pode organizar por autor (RBF kernel), por período histórico (Periódico kernel), ou por complexidade do texto (Linear kernel). Cada método revela diferentes tipos de similaridades entre os livros. No mundo dos Processos Gaussianos, os kernels são exatamente isso – funções que definem como medimos a “similaridade” entre pontos de dados, moldando completamente o comportamento e a personalidade do seu modelo.

Como isso funciona na prática?

Os kernels (ou núcleos) são o coração dos Processos Gaussianos – eles definem a função de covariância que especifica como os valores da função em pontos diferentes se relacionam. Pense no kernel como uma lente através da qual o modelo enxerga os dados: um kernel RBF assume que pontos próximos têm valores similares, criando funções suaves; um kernel periódico captura padrões que se repetem; um kernel linear modela relações lineares. A API de kernels do Scikit-Learn permite combinar, escalar e transformar esses kernels como peças de Lego, criando modelos customizados para padrões complexos do mundo real.

Mãos na massa: explorando a galeria de kernels do Scikit-Learn

"""
Explorando a API de Kernels para Processos Gaussianos no Scikit-Learn
Demonstra como diferentes kernels capturam diferentes tipos de padrões
"""

import numpy as np
import matplotlib.pyplot as plt
from sklearn.gaussian_process.kernels import (RBF, Matern, RationalQuadratic, 
                                              ExpSineSquared, DotProduct, 
                                              ConstantKernel, WhiteKernel)
from sklearn.gaussian_process import GaussianProcessRegressor

# Criando dados de exemplo com diferentes padrões
def criar_dados_exemplo():
    """Cria dados com múltiplos padrões para demonstrar diferentes kernels"""
    np.random.seed(42)
    x = np.linspace(0, 10, 100).reshape(-1, 1)
    
    # Padrão 1: Tendência suave + ruído
    y_smooth = np.sin(x.ravel()) + 0.1 * np.random.normal(size=100)
    
    # Padrão 2: Sazonalidade periódica
    y_periodic = np.sin(2 * np.pi * x.ravel()) + 0.1 * np.random.normal(size=100)
    
    # Padrão 3: Variações em múltiplas escalas
    y_multiscale = (np.sin(x.ravel()) + 
                    0.3 * np.sin(3 * x.ravel()) + 
                    0.1 * np.random.normal(size=100))
    
    # Padrão 4: Tendência linear
    y_linear = 0.5 * x.ravel() + 0.1 * np.random.normal(size=100)
    
    return x, [y_smooth, y_periodic, y_multiscale, y_linear]

x, padroes_y = criar_dados_exemplo()
nomes_padroes = ['Suave', 'Periódico', 'Múltiplas Escalas', 'Linear']

# Definindo uma galeria de kernels
kernels = {
    'RBF': RBF(length_scale=1.0),
    'RBF Otimizado': RBF(),
    'Matern (ν=1.5)': Matern(length_scale=1.0, nu=1.5),
    'Matern (ν=2.5)': Matern(length_scale=1.0, nu=2.5),
    'Periódico': ExpSineSquared(length_scale=1.0, periodicity=1.0),
    'RationalQuadratic': RationalQuadratic(length_scale=1.0, alpha=1.0),
    'Linear': DotProduct(sigma_0=1.0),
    'Composto (RBF + Periódico)': RBF(length_scale=1.0) * ExpSineSquared(length_scale=1.0, periodicity=1.0)
}

print("=== GALERIA DE KERNELS DO SCIKIT-LEARN ===\n")

# Testando cada kernel em diferentes padrões
fig, axes = plt.subplots(len(kernels), len(padroes_y), figsize=(20, 16))

for i, (nome_kernel, kernel) in enumerate(kernels.items()):
    print(f"Kernel: {nome_kernel}")
    
    for j, (y, nome_padrao) in enumerate(zip(padroes_y, nomes_padroes)):
        ax = axes[i, j]
        
        try:
            # Criando e treinando GPR com o kernel
            gpr = GaussianProcessRegressor(kernel=kernel, alpha=0.1, random_state=42)
            gpr.fit(x, y)
            
            # Fazendo previsões
            x_pred = np.linspace(0, 10, 200).reshape(-1, 1)
            y_pred, sigma = gpr.predict(x_pred, return_std=True)
            
            # Plotando resultados
            ax.plot(x, y, 'ro', alpha=0.6, markersize=4, label='Dados')
            ax.plot(x_pred, y_pred, 'b-', linewidth=2, label='Previsão')
            ax.fill_between(x_pred.ravel(), 
                          y_pred - 1.96*sigma, 
                          y_pred + 1.96*sigma, 
                          alpha=0.2, color='blue', label='Incerteza')
            
            # Informações do kernel otimizado
            if hasattr(gpr.kernel_, 'theta'):
                kernel_info = f"θ={gpr.kernel_.theta[0]:.2f}" if len(gpr.kernel_.theta) == 1 else "θ otimizado"
            else:
                kernel_info = "Parâmetros fixos"
            
            ax.set_title(f'{nome_kernel}\n{nome_padrao}\n{kernel_info}', fontsize=9)
            ax.grid(True, alpha=0.3)
            
            # Apenas primeira coluna tem labels y
            if j == 0:
                ax.set_ylabel('y')
            
            # Apenas última linha tem labels x
            if i == len(kernels) - 1:
                ax.set_xlabel('x')
                
        except Exception as e:
            ax.text(0.5, 0.5, f'Erro:\n{str(e)}', 
                   ha='center', va='center', transform=ax.transAxes, fontsize=8)
            ax.set_title(f'{nome_kernel}\n{nome_padrao}\nERRO', fontsize=9)

plt.tight_layout()
plt.show()

# Demonstração da API de composição de kernels
print("\n=== API DE COMPOSIÇÃO DE KERNELS ===")

# Kernel constante para escala
k_const = ConstantKernel(constant_value=1.0, constant_value_bounds=(1e-5, 1e5))

# Kernels base
k_rbf = RBF(length_scale=1.0, length_scale_bounds=(1e-2, 1e2))
k_periodic = ExpSineSquared(length_scale=1.0, periodicity=1.0, 
                           periodicity_bounds=(1e-2, 1e2))
k_linear = DotProduct(sigma_0=1.0, sigma_0_bounds=(1e-5, 1e5))
k_noise = WhiteKernel(noise_level=0.1, noise_level_bounds=(1e-5, 1e2))

# Combinando kernels
kernel_complexo = (
    k_const * k_rbf +                    # Componente suave
    k_const * k_periodic +               # Componente periódico  
    k_linear +                           # Componente linear
    k_noise                              # Ruído
)

print("Kernel complexo construído:")
print(f"Expressão: {kernel_complexo}")
print(f"Hiperparâmetros: {kernel_complexo.hyperparameters}")

# Testando o kernel complexo em dados com múltiplos padrões
x_complex = np.linspace(0, 10, 50).reshape(-1, 1)
y_complex = (np.sin(x_complex.ravel()) +                    # Padrão suave
             0.5 * np.sin(3 * x_complex.ravel()) +         # Padrão periódico
             0.1 * x_complex.ravel() +                     # Tendência linear
             0.1 * np.random.normal(size=50))              # Ruído

gpr_complex = GaussianProcessRegressor(kernel=kernel_complexo, random_state=42)
gpr_complex.fit(x_complex, y_complex)

print(f"\nKernel complexo otimizado:")
print(f"Antes: {kernel_complexo}")
print(f"Depois: {gpr_complex.kernel_}")
print(f"Log-marginal-likelihood: {gpr_complex.log_marginal_likelihood():.2f}")

# Visualizando o kernel complexo
plt.figure(figsize=(12, 4))

# Plot das previsões
plt.subplot(1, 2, 1)
x_pred_complex = np.linspace(0, 10, 100).reshape(-1, 1)
y_pred_complex, sigma_complex = gpr_complex.predict(x_pred_complex, return_std=True)

plt.plot(x_complex, y_complex, 'ro', alpha=0.8, label='Dados')
plt.plot(x_pred_complex, y_pred_complex, 'b-', label='Previsão')
plt.fill_between(x_pred_complex.ravel(), 
                y_pred_complex - 1.96*sigma_complex, 
                y_pred_complex + 1.96*sigma_complex, 
                alpha=0.2, label='Incerteza 95%')
plt.title('Kernel Complexo: Capturando Múltiplos Padrões')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True, alpha=0.3)

# Plot da matriz de covariância do kernel
plt.subplot(1, 2, 2)
x_cov = np.linspace(0, 5, 50).reshape(-1, 1)
ponto_fixo = np.array([[2.5]])
K = gpr_complex.kernel_(x_cov, ponto_fixo)

plt.plot(x_cov, K, 'g-', linewidth=2)
plt.axvline(x=2.5, color='red', linestyle='--', alpha=0.7, label='Ponto de referência')
plt.title('Função de Covariância do Kernel\n(Similaridade com ponto x=2.5)')
plt.xlabel('x')
plt.ylabel('Covariância')
plt.legend()
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

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

167

168

169

170

171

172

173

174

175

176

177

178

"""

Explorando a API de Kernels para Processos Gaussianos no Scikit-Learn

Demonstra como diferentes kernels capturam diferentes tipos de padrões

"""

import numpy as np

import matplotlib.pyplot as plt

from sklearn.gaussian_process.kernels import (RBF, Matern, RationalQuadratic,

ExpSineSquared, DotProduct,

ConstantKernel, WhiteKernel)

from sklearn.gaussian_process import GaussianProcessRegressor

# Criando dados de exemplo com diferentes padrões

def criar_dados_exemplo():

"""Cria dados com múltiplos padrões para demonstrar diferentes kernels"""

np.random.seed(42)

x = np.linspace(0, 10, 100).reshape(-1, 1)

# Padrão 1: Tendência suave + ruído

y_smooth = np.sin(x.ravel()) + 0.1 * np.random.normal(size=100)

# Padrão 2: Sazonalidade periódica

y_periodic = np.sin(2 * np.pi * x.ravel()) + 0.1 * np.random.normal(size=100)

# Padrão 3: Variações em múltiplas escalas

y_multiscale = (np.sin(x.ravel()) +

0.3 * np.sin(3 * x.ravel()) +

0.1 * np.random.normal(size=100))

# Padrão 4: Tendência linear

y_linear = 0.5 * x.ravel() + 0.1 * np.random.normal(size=100)

return x, [y_smooth, y_periodic, y_multiscale, y_linear]

x, padroes_y = criar_dados_exemplo()

nomes_padroes = ['Suave', 'Periódico', 'Múltiplas Escalas', 'Linear']

# Definindo uma galeria de kernels

kernels = {

'RBF': RBF(length_scale=1.0),

'RBF Otimizado': RBF(),

'Matern (ν=1.5)': Matern(length_scale=1.0, nu=1.5),

'Matern (ν=2.5)': Matern(length_scale=1.0, nu=2.5),

'Periódico': ExpSineSquared(length_scale=1.0, periodicity=1.0),

'RationalQuadratic': RationalQuadratic(length_scale=1.0, alpha=1.0),

'Linear': DotProduct(sigma_0=1.0),

'Composto (RBF + Periódico)': RBF(length_scale=1.0) * ExpSineSquared(length_scale=1.0, periodicity=1.0)

}

print("=== GALERIA DE KERNELS DO SCIKIT-LEARN ===\n")

# Testando cada kernel em diferentes padrões

fig, axes = plt.subplots(len(kernels), len(padroes_y), figsize=(20, 16))

for i, (nome_kernel, kernel) in enumerate(kernels.items()):

print(f"Kernel: {nome_kernel}")

for j, (y, nome_padrao) in enumerate(zip(padroes_y, nomes_padroes)):

ax = axes[i, j]

try:

# Criando e treinando GPR com o kernel

gpr = GaussianProcessRegressor(kernel=kernel, alpha=0.1, random_state=42)

gpr.fit(x, y)

# Fazendo previsões

x_pred = np.linspace(0, 10, 200).reshape(-1, 1)

y_pred, sigma = gpr.predict(x_pred, return_std=True)

# Plotando resultados

ax.plot(x, y, 'ro', alpha=0.6, markersize=4, label='Dados')

ax.plot(x_pred, y_pred, 'b-', linewidth=2, label='Previsão')

ax.fill_between(x_pred.ravel(),

y_pred - 1.96*sigma,

y_pred + 1.96*sigma,

alpha=0.2, color='blue', label='Incerteza')

# Informações do kernel otimizado

if hasattr(gpr.kernel_, 'theta'):

kernel_info = f"θ={gpr.kernel_.theta[0]:.2f}" if len(gpr.kernel_.theta) == 1 else "θ otimizado"

else:

kernel_info = "Parâmetros fixos"

ax.set_title(f'{nome_kernel}\n{nome_padrao}\n{kernel_info}', fontsize=9)

ax.grid(True, alpha=0.3)

# Apenas primeira coluna tem labels y

if j == 0:

ax.set_ylabel('y')

# Apenas última linha tem labels x

if i == len(kernels) - 1:

ax.set_xlabel('x')

except Exception as e:

ax.text(0.5, 0.5, f'Erro:\n{str(e)}',

ha='center', va='center', transform=ax.transAxes, fontsize=8)

ax.set_title(f'{nome_kernel}\n{nome_padrao}\nERRO', fontsize=9)

plt.tight_layout()

plt.show()

# Demonstração da API de composição de kernels

print("\n=== API DE COMPOSIÇÃO DE KERNELS ===")

# Kernel constante para escala

k_const = ConstantKernel(constant_value=1.0, constant_value_bounds=(1e-5, 1e5))

# Kernels base

k_rbf = RBF(length_scale=1.0, length_scale_bounds=(1e-2, 1e2))

k_periodic = ExpSineSquared(length_scale=1.0, periodicity=1.0,

periodicity_bounds=(1e-2, 1e2))

k_linear = DotProduct(sigma_0=1.0, sigma_0_bounds=(1e-5, 1e5))

k_noise = WhiteKernel(noise_level=0.1, noise_level_bounds=(1e-5, 1e2))

# Combinando kernels

kernel_complexo = (

k_const * k_rbf + # Componente suave

k_const * k_periodic + # Componente periódico

k_linear + # Componente linear

k_noise # Ruído

)

print("Kernel complexo construído:")

print(f"Expressão: {kernel_complexo}")

print(f"Hiperparâmetros: {kernel_complexo.hyperparameters}")

# Testando o kernel complexo em dados com múltiplos padrões

x_complex = np.linspace(0, 10, 50).reshape(-1, 1)

y_complex = (np.sin(x_complex.ravel()) + # Padrão suave

0.5 * np.sin(3 * x_complex.ravel()) + # Padrão periódico

0.1 * x_complex.ravel() + # Tendência linear

0.1 * np.random.normal(size=50)) # Ruído

gpr_complex = GaussianProcessRegressor(kernel=kernel_complexo, random_state=42)

gpr_complex.fit(x_complex, y_complex)

print(f"\nKernel complexo otimizado:")

print(f"Antes: {kernel_complexo}")

print(f"Depois: {gpr_complex.kernel_}")

print(f"Log-marginal-likelihood: {gpr_complex.log_marginal_likelihood():.2f}")

# Visualizando o kernel complexo

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

# Plot das previsões

plt.subplot(1, 2, 1)

x_pred_complex = np.linspace(0, 10, 100).reshape(-1, 1)

y_pred_complex, sigma_complex = gpr_complex.predict(x_pred_complex, return_std=True)

plt.plot(x_complex, y_complex, 'ro', alpha=0.8, label='Dados')

plt.plot(x_pred_complex, y_pred_complex, 'b-', label='Previsão')

plt.fill_between(x_pred_complex.ravel(),

y_pred_complex - 1.96*sigma_complex,

y_pred_complex + 1.96*sigma_complex,

alpha=0.2, label='Incerteza 95%')

plt.title('Kernel Complexo: Capturando Múltiplos Padrões')

plt.xlabel('x')

plt.ylabel('y')

plt.legend()

plt.grid(True, alpha=0.3)

# Plot da matriz de covariância do kernel

plt.subplot(1, 2, 2)

x_cov = np.linspace(0, 5, 50).reshape(-1, 1)

ponto_fixo = np.array([[2.5]])

K = gpr_complex.kernel_(x_cov, ponto_fixo)

plt.plot(x_cov, K, 'g-', linewidth=2)

plt.axvline(x=2.5, color='red', linestyle='--', alpha=0.7, label='Ponto de referência')

plt.title('Função de Covariância do Kernel\n(Similaridade com ponto x=2.5)')

plt.xlabel('x')

plt.ylabel('Covariância')

plt.legend()

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

Os detalhes que fazem diferença

A escolha do kernel é provavelmente a decisão mais importante ao usar Processos Gaussianos. O kernel RBF é um ótimo ponto de partida para a maioria dos problemas, criando funções suaves e infinitamente diferenciáveis. Contudo, o kernel Matern oferece mais controle sobre a suavidade através do parâmetro ν – valores menores criam funções mais irregulares, valores maiores criam funções mais suaves. A API do Scikit-Learn permite operações algébricas entre kernels: adição combina padrões, multiplicação cria interações, e exponenciação controla a escala. Definir bounds realistas para os hiperparâmetros é crucial para evitar overfitting e garantir que a otimização encontre soluções significativas.

RBF: Padrão ouro para funções suaves, infinitamente diferenciável
Matern: Controle explícito da suavidade via parâmetro ν
ExpSineSquared: Ideal para padrões periódicos e sazonais
Operações: + combina, × interage, ** escala kernels
Bounds: Sempre defina limites realistas para hiperparâmetros

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Como escolher o kernel certo para meu problema?” Comece com RBF para problemas gerais e observe os resíduos – padrões periódicos nos resíduos sugerem ExpSineSquared, tendências lineares sugerem DotProduct. Uma confusão comum é pensar que kernels mais complexos são sempre melhores – na verdade, kernels simples frequentemente generalizam melhor. Outra dúvida frequente: “Preciso sempre otimizar os hiperparâmetros?” Sim! Deixar o Scikit-Learn otimizar os parâmetros via máxima verossimilhança marginal é essencial para bons resultados, mas defina bounds sensatos baseados no seu domínio.

Para onde ir agora?

Experimente criar kernels customizados combinando os kernels básicos para capturar padrões específicos do seu domínio. Use a log-verossimilhança marginal para comparar diferentes kernels objetivamente. Visualize a matriz de covariância para entender como cada kernel “enxerga” similaridades entre pontos. O momento “aha!” acontece quando você percebe que kernels diferentes revelam diferentes aspectos dos seus dados, como diferentes lentes fotográficas revelam diferentes características de uma paisagem.

Assuntos relacionados

Para dominar kernels de GP, estude:

Teoria de kernels: propriedades de funções positivas definidas
Espaços de Hilbert: fundamentos matemáticos dos métodos de kernel
Processos estocásticos: covariância e estrutura de dependência
Otimização de hiperparâmetros: métodos baseados em gradiente e grid search
Teoria espectral: decomposição de operadores de covariância

Referências que valem a pena

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