Imagine que você está gerenciando os custos de uma rede de padarias. Para o orçamento do próximo trimestre, você precisa tanto de estimativas precisas quanto de entender os riscos. A Regressão Ridge com Kernel lhe dá números exatos, enquanto o Processo Gaussiano (GPR) fornece essas estimativas junto com uma medida de confiança. É a diferença entre receber apenas o preço previsto de uma ação versus receber o preço mais a volatilidade esperada – ambas são úteis, mas para decisões diferentes.
Como isso funciona na prática?
Ambos os métodos usam kernels para modelar relações não-lineares nos dados, mas com filosofias fundamentalmente diferentes. A Regressão Ridge com Kernel é um método frequentista que encontra uma única função ótima que minimiza erro mais regularização. Contudo, o GPR é bayesiano e modela uma distribuição sobre funções possíveis, fornecendo não apenas uma previsão mas toda uma distribuição de possibilidades. Enquanto Ridge dá uma resposta definitiva (“o custo será R$ X”), GPR responde (“o custo provavelmente será around R$ X, mas pode variar entre Y e Z”).
Mãos na massa: comparando previsões de custos
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 |
""" Comparação prática entre GPR e Regressão Ridge com Kernel Ambos usam kernels RBF, mas com abordagens fundamentalmente diferentes """ import numpy as np import matplotlib.pyplot as plt from sklearn.gaussian_process import GaussianProcessRegressor from sklearn.gaussian_process.kernels import RBF from sklearn.kernel_ridge import KernelRidge from sklearn.model_selection import train_test_split from sklearn.metrics import mean_squared_error, mean_absolute_error # Dados de custos mensais de produção com sazonalidade np.random.seed(42) meses = np.linspace(0, 24, 50).reshape(-1, 1) # Função base com sazonalidade + ruído custos_base = 5000 + 200 * meses + 300 * np.sin(2 * np.pi * meses / 12) custos = custos_base + np.random.normal(0, 150, meses.shape) # Dividindo em treino e teste X_treino, X_teste, y_treino, y_teste = train_test_split( meses, custos, test_size=0.3, random_state=42 ) print(f"Dados: {len(X_treino)} meses para treino, {len(X_teste)} para teste") # Configurando ambos os modelos com kernel RBF similar kernel_rbf = RBF(length_scale=1.0) # Gaussian Process Regressor gpr = GaussianProcessRegressor( kernel=kernel_rbf, alpha=100, # Ruído nos dados n_restarts_optimizer=10 ) # Kernel Ridge Regression krr = KernelRidge( kernel='rbf', alpha=1.0, # Parâmetro de regularização gamma=0.5 # Parâmetro do kernel RBF ) # Treinando ambos os modelos gpr.fit(X_treino, y_treino.ravel()) krr.fit(X_treino, y_treino.ravel()) # Fazendo previsões X_plot = np.linspace(0, 24, 100).reshape(-1, 1) # GPR fornece média e incerteza y_gpr, sigma_gpr = gpr.predict(X_plot, return_std=True) # KRR fornece apenas previsão pontual y_krr = krr.predict(X_plot) # Avaliando no conjunto de teste y_pred_gpr = gpr.predict(X_teste) y_pred_krr = krr.predict(X_teste) mse_gpr = mean_squared_error(y_teste, y_pred_gpr) mse_krr = mean_squared_error(y_teste, y_pred_krr) print(f"\nDesempenho nos dados de teste:") print(f"GPR - Erro quadrático médio: {mse_gpr:.2f}") print(f"KRR - Erro quadrático médio: {mse_krr:.2f}") # Visualizando a comparação plt.figure(figsize=(14, 10)) plt.subplot(2, 1, 1) plt.scatter(X_treino, y_treino, c='blue', alpha=0.6, label='Dados de treino') plt.scatter(X_teste, y_teste, c='red', alpha=0.6, label='Dados de teste') plt.plot(X_plot, y_gpr, 'green', linewidth=2, label='GPR - Previsão média') plt.fill_between(X_plot.ravel(), y_gpr - 1.96*sigma_gpr, y_gpr + 1.96*sigma_gpr, alpha=0.2, color='green', label='GPR - 95% intervalo') plt.title('Gaussian Process Regressor - Previsão com Incerteza') plt.xlabel('Mês') plt.ylabel('Custo (R$)') plt.legend() plt.grid(True, alpha=0.3) plt.subplot(2, 1, 2) plt.scatter(X_treino, y_treino, c='blue', alpha=0.6, label='Dados de treino') plt.scatter(X_teste, y_teste, c='red', alpha=0.6, label='Dados de teste') plt.plot(X_plot, y_krr, 'purple', linewidth=2, label='Kernel Ridge - Previsão') plt.title('Kernel Ridge Regression - Previsão Pontual') plt.xlabel('Mês') plt.ylabel('Custo (R$)') plt.legend() plt.grid(True, alpha=0.3) plt.tight_layout() plt.show() print("\nPrincipais diferenças observadas:") print("• GPR fornece intervalo de confiança junto com a previsão") print("• KRR é computacionalmente mais eficiente para grandes datasets") print("• GPR é probabilisticamente interpretável") print("• KRR é mais simples de implementar e ajustar") |
Os detalhes que fazem diferença
A escolha entre GPR e Kernel Ridge depende crucialmente das suas necessidades específicas. GPR brilha quando a quantificação da incerteza é importante ou quando você tem dados limitados mas de alta qualidade. Contudo, para grandes conjuntos de dados (acima de ~10.000 pontos), Kernel Ridge se torna muito mais eficiente computacionalmente. Analogamente importante é a interpretabilidade: GPR fornece uma framework probabilística natural, enquanto Kernel Ridge é puramente baseado em otimização. O custo computacional do GPR (\(O(n^3)\)) versus Kernel Ridge (\(O(n^2)\)) frequentemente dita a escolha prática em aplicações do mundo real.
- Escolha GPR quando: Incerteza é crucial, dados são limitados, interpretabilidade probabilística é importante
- Escolha Kernel Ridge quando: Performance computacional é prioridade, dados são abundantes, apenas previsões pontuais são necessárias
- Complexidade GPR: \(O(n^3)\) para treinamento devido à inversão de matriz
- Complexidade Kernel Ridge: \(O(n^2)\) – mais escalável
Perguntas que os iniciantes fazem
Você deve estar se perguntando: “Se ambos usam kernels, por que os resultados são tão diferentes?” Excelente observação! A diferença está na filosofia: Kernel Ridge encontra a função que melhor se ajusta aos dados, enquanto GPR modela uma distribuição sobre funções possíveis. Uma confusão comum é pensar que GPR é sempre mais preciso – na verdade, em muitos casos práticos, Kernel Ridge pode ter erro similar com muito menos custo computacional. Outra dúvida frequente: “Posso usar os intervalos de confiança do GPR para tomada de decisão?” Sim! Eles são matematicamente fundamentados e podem guiar decisões de risco.
Para onde ir agora?
Experimente ambos os métodos em seus próprios dados de custos ou outros problemas de regressão. Comece com Kernel Ridge para uma solução rápida e eficiente, depois use GPR quando precisar entender a incerteza das previsões. Compare não apenas a precisão, mas também o tempo de treinamento e os insights que cada método proporciona. O momento “aha!” acontece quando você percebe que a “melhor” escolha depende do que você precisa: velocidade ou informação probabilística.
Assuntos relacionados
Para entender profundamente essas diferenças, estude:
- Estatística frequentista vs bayesiana: filosofias fundamentais diferentes
- Teoria de kernels: representação em espaços de características
- Otimização convexa: como cada método encontra soluções
- Teoria da decisão: usando incerteza para tomada de decisão
- Complexidade computacional: trade-offs entre precisão e eficiência