Arquivo de Python - Página 21 de 92

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

19/12/202531/10/2025 Por antonino

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

Como isso funciona na prática?

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

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

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

import numpy as np
import matplotlib.pyplot as plt
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix

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

X, y = criar_dados_labirinto()

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

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

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

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

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

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

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

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

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

visualizar_fronteiras()

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

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

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

"""

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

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

"""

import numpy as np

import matplotlib.pyplot as plt

from sklearn.gaussian_process import GaussianProcessClassifier

from sklearn.gaussian_process.kernels import RBF

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score, confusion_matrix

# Criando dados simulados de um labirinto

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

def criar_dados_labirinto():

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

np.random.seed(42)

n_amostras = 500

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

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

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

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

def eh_caminho_correto(x1, x2, x3):

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

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

return X, y

X, y = criar_dados_labirinto()

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

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

# Dividindo em treino e teste

X_treino, X_teste, y_treino, y_teste = train_test_split(

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

)

# Criando o classificador por processo gaussiano

kernel = 1.0 * RBF(length_scale=1.0)

gpc = GaussianProcessClassifier(

kernel=kernel,

random_state=42,

n_restarts_optimizer=5

)

print("\nTreinando GPC...")

gpc.fit(X_treino, y_treino)

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

# Fazendo previsões probabilísticas

y_pred = gpc.predict(X_teste)

y_prob = gpc.predict_proba(X_teste)

# Avaliando o modelo

acuracia = accuracy_score(y_teste, y_pred)

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

# Analisando as probabilidades

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

for i in range(5):

prob_classe_1 = y_prob[i, 1]

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

confianca = max(y_prob[i])

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

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

def visualizar_fronteiras():

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

# Criando grid para visualização

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

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

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

np.linspace(x2_min, x2_max, 50))

# Usando valor médio para terceira dimensão

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

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

# Previsões do GPC

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

Z = Z.reshape(xx1.shape)

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

# Plot das probabilidades

plt.subplot(1, 2, 1)

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

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

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

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

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

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

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

# Plot das regiões de incerteza

plt.subplot(1, 2, 2)

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

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

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

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

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

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

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

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

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

plt.tight_layout()

plt.show()

visualizar_fronteiras()

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

probabilidades_teste = gpc.predict_proba(X_teste)

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

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

casos_dificeis = incertezas > 0.4

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

Os detalhes que fazem diferença

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

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

Perguntas que os iniciantes fazem

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

Para onde ir agora?

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

Assuntos relacionados

Para dominar o GPC, estude estes conceitos:

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

Referências que valem a pena

Prever o futuro do planeta: como processos gaussianos modelam as mudanças climáticas

19/12/202531/10/2025 Por antonino

Imagine que você é um cientista climático analisando décadas de dados de CO₂ do observatório de Mauna Loa no Havaí. Você vê padrões complexos: uma tendência de longo prazo de aumento, flutuações sazonais anuais e variações aleatórias. Prever como evoluirá essa curva vital para nosso planeta requer um método que capture todos esses padrões simultaneamente. O Processo Gaussiano é a ferramenta perfeita para esta tarefa, conseguindo modelar tendências, sazonalidades e incertezas em uma única framework coerente.

Como isso funciona na prática?

O exemplo de Mauna Loa demonstra o poder dos processos gaussianos para modelar séries temporais complexas com múltiplos componentes. O segredo está na combinação inteligente de kernels que capturam diferentes aspectos dos dados: um kernel para a tendência de longo prazo, outro para a sazonalidade anual e um terceiro para variações residuais. Diferentemente de métodos que exigem decomposição manual dos componentes, o GPR aprende automaticamente a importância relativa de cada padrão. Esta abordagem permite não apenas prever valores futuros, mas quantificar realisticamente a incerteza dessas previsões – informação crucial para políticas climáticas.

Mãos na massa: modelando CO₂ com kernels compostos

"""
Modelagem de dados de CO₂ de Mauna Loa com Processos Gaussianos
Demonstra como kernels compostos capturam tendências complexas
"""

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

# Carregando dados de CO₂ (simulados para exemplo)
# Na prática, você usaria dados reais de https://www.esrl.noaa.gov/gmd/ccgg/trends/
def carregar_dados_co2_simulados():
    """Simula dados similares aos de Mauna Loa"""
    np.random.seed(42)
    # Período de 1990-2020 em meses
    anos = np.linspace(1990, 2020, 30*12)
    
    # Componentes: tendência + sazonalidade + ruído
    tendencia = 350 + 2.0 * (anos - 1990)  # Aumento linear
    sazonalidade = 3.0 * np.sin(2 * np.pi * (anos - 1990))  # Sazonalidade anual
    ruido = np.random.normal(0, 0.5, len(anos))  # Ruído de medição
    
    co2 = tendencia + sazonalidade + ruido
    return anos.reshape(-1, 1), co2

X, y = carregar_dados_co2_simulados()

print(f"Dados de CO₂ carregados: {len(X)} meses de medições")
print(f"Variação de CO₂: {y.min():.1f} a {y.max():.1f} ppm")

# Kernel composto para capturar diferentes componentes temporais
kernel = (
    1.0 * RBF(length_scale=50.0) +                    # Tendência de longo prazo
    1.0 * ExpSineSquared(length_scale=1.0, periodicity=1.0) +  # Sazonalidade anual
    1.0 * RationalQuadratic(length_scale=1.0, alpha=1.0) +     # Variações de médio prazo
    1.0 * WhiteKernel(noise_level=0.1)               # Ruído de medição
)

# Criando e treinando o GPR
gpr = GaussianProcessRegressor(
    kernel=kernel,
    alpha=0.0,
    normalize_y=True,
    n_restarts_optimizer=9
)

# Dividindo em treino (até 2015) e teste (após 2015)
mask_treino = X.ravel() <= 2015
X_treino, y_treino = X[mask_treino], y[mask_treino]
X_teste, y_teste = X[~mask_treino], y[~mask_treino]

print(f"\nTreinando com {len(X_treino)} pontos (até 2015)")
print(f"Testando com {len(X_teste)} pontos (2016-2020)")

gpr.fit(X_treino, y_treino)

print(f"\nKernel otimizado: {gpr.kernel_}")

# Fazendo previsões para o futuro
X_futuro = np.linspace(2021, 2030, 120).reshape(-1, 1)
y_pred, sigma = gpr.predict(X_futuro, return_std=True)

# Visualizando resultados
plt.figure(figsize=(14, 10))

# Plot principal
plt.subplot(2, 1, 1)
plt.plot(X_treino, y_treino, 'b.', alpha=0.6, label='Dados de treino (1990-2015)')
plt.plot(X_teste, y_teste, 'r.', alpha=0.6, label='Dados de teste (2016-2020)')
plt.plot(X_futuro, y_pred, 'g-', linewidth=2, label='Previsão GPR (2021-2030)')
plt.fill_between(X_futuro.ravel(), 
                y_pred - 1.96*sigma, 
                y_pred + 1.96*sigma, 
                alpha=0.3, color='green', label='95% intervalo de confiança')

plt.xlabel('Ano')
plt.ylabel('CO₂ (ppm)')
plt.title('Previsão de CO₂ com Processo Gaussiano - Mauna Loa Simulado')
plt.legend()
plt.grid(True, alpha=0.3)

# Zoom na área de previsão
plt.subplot(2, 1, 2)
zoom_mask = (X.ravel() >= 2010) | (X_futuro.ravel() <= 2030)
X_zoom = np.concatenate([X[X.ravel() >= 2010], X_futuro])
y_zoom_actual = np.concatenate([y[X.ravel() >= 2010], [np.nan] * len(X_futuro)])
y_zoom_pred = np.concatenate([[np.nan] * sum(X.ravel() >= 2010), y_pred])

plt.plot(X_zoom, y_zoom_actual, 'ro-', alpha=0.7, label='Dados observados')
plt.plot(X_zoom, y_zoom_pred, 'g-', linewidth=2, label='Previsão GPR')
plt.fill_between(X_futuro.ravel(), 
                y_pred - 1.96*sigma, 
                y_pred + 1.96*sigma, 
                alpha=0.3, color='green', label='Incerteza')

plt.xlabel('Ano')
plt.ylabel('CO₂ (ppm)')
plt.title('Zoom: Previsões 2021-2030 e Incerteza')
plt.legend()
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Análise das previsões
print(f"\nPrevisões para 2030:")
print(f"CO₂ esperado: {y_pred[-1]:.1f} ppm")
print(f"Intervalo de 95% confiança: {y_pred[-1] - 1.96*sigma[-1]:.1f} a {y_pred[-1] + 1.96*sigma[-1]:.1f} ppm")

100

101

102

103

104

105

106

107

108

109

"""

Modelagem de dados de CO₂ de Mauna Loa com Processos Gaussianos

Demonstra como kernels compostos capturam tendências complexas

"""

import numpy as np

import matplotlib.pyplot as plt

from sklearn.gaussian_process import GaussianProcessRegressor

from sklearn.gaussian_process.kernels import RBF, ExpSineSquared, RationalQuadratic, WhiteKernel

# Carregando dados de CO₂ (simulados para exemplo)

# Na prática, você usaria dados reais de https://www.esrl.noaa.gov/gmd/ccgg/trends/

def carregar_dados_co2_simulados():

"""Simula dados similares aos de Mauna Loa"""

np.random.seed(42)

# Período de 1990-2020 em meses

anos = np.linspace(1990, 2020, 30*12)

# Componentes: tendência + sazonalidade + ruído

tendencia = 350 + 2.0 * (anos - 1990) # Aumento linear

sazonalidade = 3.0 * np.sin(2 * np.pi * (anos - 1990)) # Sazonalidade anual

ruido = np.random.normal(0, 0.5, len(anos)) # Ruído de medição

co2 = tendencia + sazonalidade + ruido

return anos.reshape(-1, 1), co2

X, y = carregar_dados_co2_simulados()

print(f"Dados de CO₂ carregados: {len(X)} meses de medições")

print(f"Variação de CO₂: {y.min():.1f} a {y.max():.1f} ppm")

# Kernel composto para capturar diferentes componentes temporais

kernel = (

1.0 * RBF(length_scale=50.0) + # Tendência de longo prazo

1.0 * ExpSineSquared(length_scale=1.0, periodicity=1.0) + # Sazonalidade anual

1.0 * RationalQuadratic(length_scale=1.0, alpha=1.0) + # Variações de médio prazo

1.0 * WhiteKernel(noise_level=0.1) # Ruído de medição

)

# Criando e treinando o GPR

gpr = GaussianProcessRegressor(

kernel=kernel,

alpha=0.0,

normalize_y=True,

n_restarts_optimizer=9

)

# Dividindo em treino (até 2015) e teste (após 2015)

mask_treino = X.ravel() <= 2015

X_treino, y_treino = X[mask_treino], y[mask_treino]

X_teste, y_teste = X[~mask_treino], y[~mask_treino]

print(f"\nTreinando com {len(X_treino)} pontos (até 2015)")

print(f"Testando com {len(X_teste)} pontos (2016-2020)")

gpr.fit(X_treino, y_treino)

print(f"\nKernel otimizado: {gpr.kernel_}")

# Fazendo previsões para o futuro

X_futuro = np.linspace(2021, 2030, 120).reshape(-1, 1)

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

# Visualizando resultados

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

# Plot principal

plt.subplot(2, 1, 1)

plt.plot(X_treino, y_treino, 'b.', alpha=0.6, label='Dados de treino (1990-2015)')

plt.plot(X_teste, y_teste, 'r.', alpha=0.6, label='Dados de teste (2016-2020)')

plt.plot(X_futuro, y_pred, 'g-', linewidth=2, label='Previsão GPR (2021-2030)')

plt.fill_between(X_futuro.ravel(),

y_pred - 1.96*sigma,

y_pred + 1.96*sigma,

alpha=0.3, color='green', label='95% intervalo de confiança')

plt.xlabel('Ano')

plt.ylabel('CO₂ (ppm)')

plt.title('Previsão de CO₂ com Processo Gaussiano - Mauna Loa Simulado')

plt.legend()

plt.grid(True, alpha=0.3)

# Zoom na área de previsão

plt.subplot(2, 1, 2)

zoom_mask = (X.ravel() >= 2010) | (X_futuro.ravel() <= 2030)

X_zoom = np.concatenate([X[X.ravel() >= 2010], X_futuro])

y_zoom_actual = np.concatenate([y[X.ravel() >= 2010], [np.nan] * len(X_futuro)])

y_zoom_pred = np.concatenate([[np.nan] * sum(X.ravel() >= 2010), y_pred])

plt.plot(X_zoom, y_zoom_actual, 'ro-', alpha=0.7, label='Dados observados')

plt.plot(X_zoom, y_zoom_pred, 'g-', linewidth=2, label='Previsão GPR')

plt.fill_between(X_futuro.ravel(),

y_pred - 1.96*sigma,

y_pred + 1.96*sigma,

alpha=0.3, color='green', label='Incerteza')

plt.xlabel('Ano')

plt.ylabel('CO₂ (ppm)')

plt.title('Zoom: Previsões 2021-2030 e Incerteza')

plt.legend()

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

# Análise das previsões

print(f"\nPrevisões para 2030:")

print(f"CO₂ esperado: {y_pred[-1]:.1f} ppm")

print(f"Intervalo de 95% confiança: {y_pred[-1] - 1.96*sigma[-1]:.1f} a {y_pred[-1] + 1.96*sigma[-1]:.1f} ppm")

Os detalhes que fazem diferença

O poder do GPR no exemplo de Mauna Loa está na combinação estratégica de kernels. O kernel ExpSineSquared é particularmente importante pois modela padrões periódicos como a sazonalidade anual do CO₂ (plantas absorvem CO₂ no verão, liberam no inverno). Contudo, a escolha dos hiperparâmetros iniciais é crucial – valores muito distantes do ótimo podem fazer a otimização falhar. Analogamente importante é entender que a incerteza cresce conforme previsões se afastam no futuro, refletindo honestamente nossa ignorância crescente. O kernel RationalQuadratic captura variações de médio prazo que não são nem totalmente periódicas nem totalmente aleatórias.

ExpSineSquared: Ideal para padrões periódicos como sazonalidade anual
RBF: Captura tendências suaves de longo prazo
RationalQuadratic: Flexível para padrões de médio prazo
WhiteKernel: Modela ruído de medição e variações não explicadas

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Por que usar tantos kernels diferentes?” Excelente questão! Cada kernel captura um tipo diferente de padrão nos dados. Usar apenas um kernel RBF, por exemplo, não conseguiria modelar adequadamente a sazonalidade anual. Uma confusão comum é pensar que mais kernels sempre significam melhor performance – na verdade, kernels desnecessários podem levar a overfitting. Outra dúvida frequente: “Como o GPR sabe qual parte é tendência e qual é sazonalidade?” A otimização dos hiperparâmetros automaticamente aprende a importância relativa de cada componente através da maximização da verossimilhança marginal.

Para onde ir agora?

Experimente aplicar GPR com kernels compostos em suas próprias séries temporais. Comece com dados climáticos, financeiros ou de negócios que exibam múltiplos padrões. Pratique a interpretação dos intervalos de confiança – eles não são apenas técnicos, mas contam uma história sobre o que sabemos e não sabemos. O momento “aha!” acontece quando você vê o modelo capturando automaticamente padrões complexos que você só conseguia ver manualmente antes.

Assuntos relacionados

Para dominar esta aplicação, estude:

Séries temporais: decomposição, estacionariedade e sazonalidade
Análise espectral: identificação de componentes periódicos
Kernels para séries temporais: propriedades e combinações
Mudanças climáticas: ciclos do carbono e dinâmica atmosférica
Incerteza em previsões: interpretação e comunicação de riscos