Arquivo de kernel - Área de Trampo

Construindo o alfabeto da similaridade: como kernels básicos e operadores criam a linguagem dos processos gaussianos

19/12/202531/10/2025 Por antonino

Imagine que você está aprendendo uma nova língua. Primeiro, você domina as letras básicas (kernels básicos), depois aprende a combiná-las em palavras (operações com kernels), e finalmente descobre que algumas letras como o ‘R’ são tão fundamentais que aparecem em quase todas as palavras (kernel RBF). No mundo dos Processos Gaussianos, os kernels básicos são seu alfabeto, os operadores são sua gramática, e o kernel RBF é como a vogal ‘A’ – tão ubíquo que se tornou o padrão para a maioria das aplicações.

Como isso funciona na prática?

Kernels básicos são as funções de covariância fundamentais que definem tipos específicos de similaridade entre pontos de dados. O kernel RBF assume que pontos próximos são similares, o kernel linear captura relações lineares, e o kernel periódico identifica padrões que se repetem. Os operadores de kernel (+, ×, **) permitem combinar esses kernels básicos como peças de Lego, criando kernels complexos que podem capturar múltiplos padrões simultaneamente. Diferentemente de escolher um único kernel, esta abordagem composicional permite construir modelos customizados que refletem a complexidade real dos seus dados.

Mãos na massa: explorando kernels básicos e suas combinações

"""
Explorando kernels básicos, operadores e o ubíquo kernel RBF
Demonstra como construir kernels complexos a partir de componentes simples
"""

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

# Criando dados de demonstração
def criar_dados_demonstracao():
    """Cria dados com múltiplos padrões para testar diferentes kernels"""
    np.random.seed(42)
    x = np.linspace(0, 10, 100).reshape(-1, 1)
    
    # Dados com padrão suave (ideal para RBF)
    y_smooth = np.sin(x.ravel()) + 0.1 * np.random.normal(size=100)
    
    # Dados com tendência linear + ruído
    y_linear = 0.5 * x.ravel() + 0.2 * np.random.normal(size=100)
    
    # Dados periódicos
    y_periodic = np.sin(2 * np.pi * x.ravel()) + 0.1 * np.random.normal(size=100)
    
    # Dados com múltiplos padrões
    y_complex = (np.sin(x.ravel()) +                    # Componente suave
                 0.3 * x.ravel() +                      # Tendência linear
                 0.5 * np.sin(3 * x.ravel()) +          # Componente periódico
                 0.1 * np.random.normal(size=100))      # Ruído
    
    return x, y_smooth, y_linear, y_periodic, y_complex

x, y_smooth, y_linear, y_periodic, y_complex = criar_dados_demonstracao()

print("=== KERNELS BÁSICOS DO SCIKIT-LEARN ===\n")

# Demonstração dos kernels básicos
kernels_basicos = {
    'RBF (Gaussiano)': RBF(length_scale=1.0),
    'Linear': DotProduct(sigma_0=1.0),
    'Periódico': ExpSineSquared(length_scale=1.0, periodicity=1.0),
    'RationalQuadratic': RationalQuadratic(length_scale=1.0, alpha=1.0),
    'Constante': ConstantKernel(constant_value=1.0),
    'Ruído': WhiteKernel(noise_level=0.1)
}

# Testando cada kernel básico nos dados suaves
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
axes = axes.ravel()

for idx, (nome, kernel) in enumerate(kernels_basicos.items()):
    try:
        gpr = GaussianProcessRegressor(kernel=kernel, alpha=0.0, random_state=42)
        gpr.fit(x, y_smooth)
        
        # Previsões
        x_pred = np.linspace(0, 10, 200).reshape(-1, 1)
        y_pred, sigma = gpr.predict(x_pred, return_std=True)
        
        # Plot
        axes[idx].plot(x, y_smooth, 'ro', alpha=0.6, markersize=3, label='Dados')
        axes[idx].plot(x_pred, y_pred, 'b-', linewidth=2, label='Previsão')
        axes[idx].fill_between(x_pred.ravel(), y_pred - 1.96*sigma, 
                             y_pred + 1.96*sigma, alpha=0.2, label='Incerteza')
        axes[idx].set_title(f'{nome}\n{kernel}', fontsize=10)
        axes[idx].grid(True, alpha=0.3)
        axes[idx].legend(fontsize=8)
        
    except Exception as e:
        axes[idx].text(0.5, 0.5, f'Erro\n{str(e)}', ha='center', va='center', 
                      transform=axes[idx].transAxes, fontsize=8)
        axes[idx].set_title(nome, fontsize=10)

plt.tight_layout()
plt.show()

print("\n=== OPERADORES DE KERNEL: COMBINANDO KERNELS BÁSICOS ===\n")

# Demonstração dos operadores de kernel
k_rbf = RBF(length_scale=1.0)
k_linear = DotProduct(sigma_0=1.0)
k_periodic = ExpSineSquared(length_scale=1.0, periodicity=1.0)
k_const = ConstantKernel(constant_value=1.0)

# Operações com kernels
operacoes_kernels = {
    'Soma\n(RBF + Linear)': k_rbf + k_linear,
    'Multiplicação\n(RBF × Periódico)': k_rbf * k_periodic,
    'Exponenciação\n(RBF²)': k_rbf**2,
    'Escala\n(Const × RBF)': k_const * k_rbf,
    'Combinação Complexa\n(Const×RBF + Linear)': k_const * k_rbf + k_linear,
    'Múltiplos Padrões\n(Const×RBF + Const×Periódico + Linear)': 
        k_const * k_rbf + k_const * k_periodic + k_linear
}

# Testando operações nos dados complexos
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
axes = axes.ravel()

for idx, (nome, kernel) in enumerate(operacoes_kernels.items()):
    try:
        gpr = GaussianProcessRegressor(kernel=kernel, alpha=0.0, random_state=42)
        gpr.fit(x, y_complex)
        
        # Previsões
        x_pred = np.linspace(0, 10, 200).reshape(-1, 1)
        y_pred, sigma = gpr.predict(x_pred, return_std=True)
        
        # Plot
        axes[idx].plot(x, y_complex, 'ro', alpha=0.6, markersize=3, label='Dados')
        axes[idx].plot(x_pred, y_pred, 'b-', linewidth=2, label='Previsão')
        axes[idx].fill_between(x_pred.ravel(), y_pred - 1.96*sigma, 
                             y_pred + 1.96*sigma, alpha=0.2, label='Incerteza')
        axes[idx].set_title(f'{nome}', fontsize=10)
        axes[idx].grid(True, alpha=0.3)
        axes[idx].legend(fontsize=8)
        
        print(f"{nome}: Log-likelihood = {gpr.log_marginal_likelihood():.2f}")
        
    except Exception as e:
        axes[idx].text(0.5, 0.5, f'Erro\n{str(e)}', ha='center', va='center', 
                      transform=axes[idx].transAxes, fontsize=8)
        axes[idx].set_title(nome, fontsize=10)

plt.tight_layout()
plt.show()

print("\n=== KERNEL RBF: O PADRÃO OURO ===\n")

# Demonstração detalhada do kernel RBF
print("O kernel RBF (Radial Basis Function) é definido por:")
print("[latex]k(x_i, x_j) = \\exp\\left(-\\frac{\\|x_i - x_j\\|^2}{2l^2}\\right)[/latex]")
print("Onde l é o parâmetro length_scale que controla a suavidade da função\n")

# Explorando diferentes length_scales no RBF
length_scales = [0.1, 0.5, 1.0, 2.0, 5.0]
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
axes = axes.ravel()

for idx, length_scale in enumerate(length_scales):
    kernel_rbf = RBF(length_scale=length_scale)
    gpr = GaussianProcessRegressor(kernel=kernel_rbf, alpha=0.0, random_state=42)
    gpr.fit(x, y_smooth)
    
    # Previsões
    x_pred = np.linspace(0, 10, 200).reshape(-1, 1)
    y_pred, sigma = gpr.predict(x_pred, return_std=True)
    
    # Plot
    axes[idx].plot(x, y_smooth, 'ro', alpha=0.6, markersize=3, label='Dados')
    axes[idx].plot(x_pred, y_pred, 'b-', linewidth=2, label='Previsão')
    axes[idx].fill_between(x_pred.ravel(), y_pred - 1.96*sigma, 
                         y_pred + 1.96*sigma, alpha=0.2, label='Incerteza')
    axes[idx].set_title(f'RBF length_scale = {length_scale}', fontsize=10)
    axes[idx].grid(True, alpha=0.3)
    axes[idx].legend(fontsize=8)
    
    print(f"length_scale {length_scale}: Log-likelihood = {gpr.log_marginal_likelihood():.2f}")

# Plot da função RBF para diferentes length_scales
axes[5].set_title('Função RBF para Diferentes length_scales', fontsize=10)
x_rbf = np.linspace(0, 3, 100)
for length_scale in length_scales:
    y_rbf = np.exp(-x_rbf**2 / (2 * length_scale**2))
    axes[5].plot(x_rbf, y_rbf, label=f'l={length_scale}', linewidth=2)
axes[5].set_xlabel('Distância')
axes[5].set_ylabel('Similaridade')
axes[5].grid(True, alpha=0.3)
axes[5].legend()

plt.tight_layout()
plt.show()

# Comparação RBF vs outros kernels nos dados suaves
print("\n=== COMPARAÇÃO: RBF VS OUTROS KERNELS ===\n")

kernels_comparacao = {
    'RBF': RBF(),
    'Matern (ν=1.5)': Matern(nu=1.5),
    'RationalQuadratic': RationalQuadratic(),
    'Linear': DotProduct()
}

resultados = []
for nome, kernel in kernels_comparacao.items():
    gpr = GaussianProcessRegressor(kernel=kernel, random_state=42)
    gpr.fit(x, y_smooth)
    log_likelihood = gpr.log_marginal_likelihood()
    resultados.append((nome, log_likelihood, gpr.kernel_))

# Ordenando por log-likelihood
resultados.sort(key=lambda x: x[1], reverse=True)

print("Ranking de kernels por log-likelihood marginal:")
for nome, ll, kernel in resultados:
    print(f"{nome:20} → Log-likelihood: {ll:8.2f} | Kernel otimizado: {kernel}")

# Caso de uso prático: escolhendo o kernel certo
print("\n=== CASO PRÁTICO: ESCOLHENDO O KERNEL CERTO ===\n")

def diagnosticar_kernel_ideal(y_data, x_data):
    """Ferramenta simples para diagnosticar qual kernel pode ser apropriado"""
    from scipy import stats
    
    # Análise de linearidade
    slope, intercept, r_value, p_value, std_err = stats.linregress(x_data.ravel(), y_data)
    
    # Análise de periodicidade (usando FFT)
    fft = np.fft.fft(y_data - np.mean(y_data))
    freqs = np.fft.fftfreq(len(y_data))
    dominant_freq = np.abs(freqs[np.argmax(np.abs(fft[1:])) + 1])
    
    print("Diagnóstico dos dados:")
    print(f"  Correlação linear (R²): {r_value**2:.3f}")
    print(f"  Frequência dominante: {dominant_freq:.3f}")
    
    recomendacoes = []
    if r_value**2 > 0.7:
        recomendacoes.append("Alta correlação linear → Considere kernel Linear")
    if dominant_freq > 0.1:
        recomendacoes.append("Padrão periódico detectado → Considere kernel Periódico")
    if len(recomendacoes) == 0:
        recomendacoes.append("Padrão complexo → Use RBF ou Matern como ponto de partida")
    
    return recomendacoes

recomendacoes = diagnosticar_kernel_ideal(y_complex, x)
print("Recomendações:")
for rec in recomendacoes:
    print(f"  • {rec}")

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

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

"""

Explorando kernels básicos, operadores e o ubíquo kernel RBF

Demonstra como construir kernels complexos a partir de componentes simples

"""

import numpy as np

import matplotlib.pyplot as plt

from sklearn.gaussian_process.kernels import (RBF, ConstantKernel,

ExpSineSquared, DotProduct,

WhiteKernel, RationalQuadratic)

from sklearn.gaussian_process import GaussianProcessRegressor

# Criando dados de demonstração

def criar_dados_demonstracao():

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

np.random.seed(42)

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

# Dados com padrão suave (ideal para RBF)

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

# Dados com tendência linear + ruído

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

# Dados periódicos

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

# Dados com múltiplos padrões

y_complex = (np.sin(x.ravel()) + # Componente suave

0.3 * x.ravel() + # Tendência linear

0.5 * np.sin(3 * x.ravel()) + # Componente periódico

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

return x, y_smooth, y_linear, y_periodic, y_complex

x, y_smooth, y_linear, y_periodic, y_complex = criar_dados_demonstracao()

print("=== KERNELS BÁSICOS DO SCIKIT-LEARN ===\n")

# Demonstração dos kernels básicos

kernels_basicos = {

'RBF (Gaussiano)': RBF(length_scale=1.0),

'Linear': DotProduct(sigma_0=1.0),

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

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

'Constante': ConstantKernel(constant_value=1.0),

'Ruído': WhiteKernel(noise_level=0.1)

}

# Testando cada kernel básico nos dados suaves

fig, axes = plt.subplots(2, 3, figsize=(15, 10))

axes = axes.ravel()

for idx, (nome, kernel) in enumerate(kernels_basicos.items()):

try:

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

gpr.fit(x, y_smooth)

# Previsões

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

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

# Plot

axes[idx].plot(x, y_smooth, 'ro', alpha=0.6, markersize=3, label='Dados')

axes[idx].plot(x_pred, y_pred, 'b-', linewidth=2, label='Previsão')

axes[idx].fill_between(x_pred.ravel(), y_pred - 1.96*sigma,

y_pred + 1.96*sigma, alpha=0.2, label='Incerteza')

axes[idx].set_title(f'{nome}\n{kernel}', fontsize=10)

axes[idx].grid(True, alpha=0.3)

axes[idx].legend(fontsize=8)

except Exception as e:

axes[idx].text(0.5, 0.5, f'Erro\n{str(e)}', ha='center', va='center',

transform=axes[idx].transAxes, fontsize=8)

axes[idx].set_title(nome, fontsize=10)

plt.tight_layout()

plt.show()

print("\n=== OPERADORES DE KERNEL: COMBINANDO KERNELS BÁSICOS ===\n")

# Demonstração dos operadores de kernel

k_rbf = RBF(length_scale=1.0)

k_linear = DotProduct(sigma_0=1.0)

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

k_const = ConstantKernel(constant_value=1.0)

# Operações com kernels

operacoes_kernels = {

'Soma\n(RBF + Linear)': k_rbf + k_linear,

'Multiplicação\n(RBF × Periódico)': k_rbf * k_periodic,

'Exponenciação\n(RBF²)': k_rbf**2,

'Escala\n(Const × RBF)': k_const * k_rbf,

'Combinação Complexa\n(Const×RBF + Linear)': k_const * k_rbf + k_linear,

'Múltiplos Padrões\n(Const×RBF + Const×Periódico + Linear)':

k_const * k_rbf + k_const * k_periodic + k_linear

}

# Testando operações nos dados complexos

fig, axes = plt.subplots(2, 3, figsize=(15, 10))

axes = axes.ravel()

for idx, (nome, kernel) in enumerate(operacoes_kernels.items()):

try:

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

gpr.fit(x, y_complex)

# Previsões

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

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

# Plot

axes[idx].plot(x, y_complex, 'ro', alpha=0.6, markersize=3, label='Dados')

axes[idx].plot(x_pred, y_pred, 'b-', linewidth=2, label='Previsão')

axes[idx].fill_between(x_pred.ravel(), y_pred - 1.96*sigma,

y_pred + 1.96*sigma, alpha=0.2, label='Incerteza')

axes[idx].set_title(f'{nome}', fontsize=10)

axes[idx].grid(True, alpha=0.3)

axes[idx].legend(fontsize=8)

print(f"{nome}: Log-likelihood = {gpr.log_marginal_likelihood():.2f}")

except Exception as e:

axes[idx].text(0.5, 0.5, f'Erro\n{str(e)}', ha='center', va='center',

transform=axes[idx].transAxes, fontsize=8)

axes[idx].set_title(nome, fontsize=10)

plt.tight_layout()

plt.show()

print("\n=== KERNEL RBF: O PADRÃO OURO ===\n")

# Demonstração detalhada do kernel RBF

print("O kernel RBF (Radial Basis Function) é definido por:")

print("[latex]k(x_i, x_j) = \\exp\\left(-\\frac{\\|x_i - x_j\\|^2}{2l^2}\\right)[/latex]")

print("Onde l é o parâmetro length_scale que controla a suavidade da função\n")

# Explorando diferentes length_scales no RBF

length_scales = [0.1, 0.5, 1.0, 2.0, 5.0]

fig, axes = plt.subplots(2, 3, figsize=(15, 10))

axes = axes.ravel()

for idx, length_scale in enumerate(length_scales):

kernel_rbf = RBF(length_scale=length_scale)

gpr = GaussianProcessRegressor(kernel=kernel_rbf, alpha=0.0, random_state=42)

gpr.fit(x, y_smooth)

# Previsões

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

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

# Plot

axes[idx].plot(x, y_smooth, 'ro', alpha=0.6, markersize=3, label='Dados')

axes[idx].plot(x_pred, y_pred, 'b-', linewidth=2, label='Previsão')

axes[idx].fill_between(x_pred.ravel(), y_pred - 1.96*sigma,

y_pred + 1.96*sigma, alpha=0.2, label='Incerteza')

axes[idx].set_title(f'RBF length_scale = {length_scale}', fontsize=10)

axes[idx].grid(True, alpha=0.3)

axes[idx].legend(fontsize=8)

print(f"length_scale {length_scale}: Log-likelihood = {gpr.log_marginal_likelihood():.2f}")

# Plot da função RBF para diferentes length_scales

axes[5].set_title('Função RBF para Diferentes length_scales', fontsize=10)

x_rbf = np.linspace(0, 3, 100)

for length_scale in length_scales:

y_rbf = np.exp(-x_rbf**2 / (2 * length_scale**2))

axes[5].plot(x_rbf, y_rbf, label=f'l={length_scale}', linewidth=2)

axes[5].set_xlabel('Distância')

axes[5].set_ylabel('Similaridade')

axes[5].grid(True, alpha=0.3)

axes[5].legend()

plt.tight_layout()

plt.show()

# Comparação RBF vs outros kernels nos dados suaves

print("\n=== COMPARAÇÃO: RBF VS OUTROS KERNELS ===\n")

kernels_comparacao = {

'RBF': RBF(),

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

'RationalQuadratic': RationalQuadratic(),

'Linear': DotProduct()

}

resultados = []

for nome, kernel in kernels_comparacao.items():

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

gpr.fit(x, y_smooth)

log_likelihood = gpr.log_marginal_likelihood()

resultados.append((nome, log_likelihood, gpr.kernel_))

# Ordenando por log-likelihood

resultados.sort(key=lambda x: x[1], reverse=True)

print("Ranking de kernels por log-likelihood marginal:")

for nome, ll, kernel in resultados:

print(f"{nome:20} → Log-likelihood: {ll:8.2f} | Kernel otimizado: {kernel}")

# Caso de uso prático: escolhendo o kernel certo

print("\n=== CASO PRÁTICO: ESCOLHENDO O KERNEL CERTO ===\n")

def diagnosticar_kernel_ideal(y_data, x_data):

"""Ferramenta simples para diagnosticar qual kernel pode ser apropriado"""

from scipy import stats

# Análise de linearidade

slope, intercept, r_value, p_value, std_err = stats.linregress(x_data.ravel(), y_data)

# Análise de periodicidade (usando FFT)

fft = np.fft.fft(y_data - np.mean(y_data))

freqs = np.fft.fftfreq(len(y_data))

dominant_freq = np.abs(freqs[np.argmax(np.abs(fft[1:])) + 1])

print("Diagnóstico dos dados:")

print(f" Correlação linear (R²): {r_value**2:.3f}")

print(f" Frequência dominante: {dominant_freq:.3f}")

recomendacoes = []

if r_value**2 > 0.7:

recomendacoes.append("Alta correlação linear → Considere kernel Linear")

if dominant_freq > 0.1:

recomendacoes.append("Padrão periódico detectado → Considere kernel Periódico")

if len(recomendacoes) == 0:

recomendacoes.append("Padrão complexo → Use RBF ou Matern como ponto de partida")

return recomendacoes

recomendacoes = diagnosticar_kernel_ideal(y_complex, x)

print("Recomendações:")

for rec in recomendacoes:

print(f" • {rec}")

Os detalhes que fazem diferença

O kernel RBF se tornou o padrão da indústria por uma boa razão: sua suavidade infinita e propriedades matemáticas elegantes o tornam apropriado para a maioria dos problemas do mundo real. Contudo, entender quando não usá-lo é igualmente importante – dados com descontinuidades podem precisar do kernel Matern, padrões sazonais exigem ExpSineSquared, e tendências lineares fortes se beneficiam do DotProduct. Os operadores de kernel permitem construir soluções híbridas: adição combina padrões independentes, multiplicação modela interações, e exponenciação controla a escala de variação. A escolha do length_scale no RBF é particularmente crucial – valores muito pequenos levam a overfitting, valores muito grandes a underfitting.

RBF: Padrão ouro para funções suaves, use quando não souber por onde começar
Operador +: Combina padrões independentes (ex: tendência + sazonalidade)
Operador ×: Modela interações entre padrões (ex: sazonalidade que varia suavemente)
Length_scale: Controla o “raio de influência” de cada ponto nos dados
Kernel constante: Escala a variância geral do processo

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Por que o RBF é tão popular se existem tantos outros kernels?” Excelente questão! O RBF é um excelente ponto de partida porque assume apenas que pontos próximos têm valores similares – uma suposição razoável para a maioria dos fenômenos naturais. Uma confusão comum é sobre quando usar soma versus multiplicação de kernels: use soma para padrões aditivos independentes, multiplicação para padrões que interagem. Outra dúvida frequente: “Como escolher o length_scale inicial?” Comece com a distância média entre pontos nos seus dados e deixe a otimização ajustar a partir daí.

Para onde ir agora?

Pratique construindo kernels customizados para problemas específicos do seu domínio. Comece sempre com RBF puro e depois adicione componentes baseando-se nos padrões que observar nos resíduos. Use a log-verossimilhança marginal para comparar objetivamente diferentes arquiteturas de kernel. O momento “aha!” acontece quando você percebe que kernels bem construídos não são apenas ferramentas matemáticas, mas expressões da sua compreensão sobre como os dados se relacionam.

Assuntos relacionados

Para se tornar um expert em kernels, estude:

Funções de base radial: fundamentos matemáticos do RBF
Teoria de aproximação: como kernels criam espaços de funções
Processos estacionários: propriedades de invariância por translação
Análise espectral: decomposição de kernels em componentes de frequência
Mercer’s Theorem: fundamento teórico dos métodos de kernel

Referências que valem a pena

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