Arquivo de Python - Página 23 de 92

Como isso funciona na prática?

Processos Gaussianos (Gaussian Processes) modelam funções como distribuições sobre funções possíveis. Pense nisso como ter múltiplas linhas de tendência possíveis para seus dados, onde algumas são mais prováveis que outras. Quando você faz uma previsão, o processo gaussiano fornece tanto uma estimativa média quanto uma medida de incerteza (variância). Diferentemente de outros métodos que dão apenas uma resposta pontual, processos gaussianos respondem: “Baseado nos dados, a função provavelmente passa por aqui, mas poderia variar tanto para mais quanto para menos.”

Mãos na massa: prevendo custos de produção com incerteza

"""
Previsão de custos de produção usando Processos Gaussianos
Modela não apenas valores esperados, mas também a incerteza das previsões
"""

import numpy as np
import matplotlib.pyplot as plt
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C

# Dados históricos de custos de produção de uma padaria
# [mês, custo_total] - meses consecutivos
X_treino = np.array([[1], [2], [3], [4], [5], [7], [8], [10]]).reshape(-1, 1)
y_treino = np.array([5200, 5400, 5800, 6200, 6500, 7200, 7800, 8500])

print("Dados históricos de custos:")
for i, (mes, custo) in enumerate(zip(X_treino, y_treino)):
    print(f"Mês {mes[0]}: R$ {custo}")

# Definindo o kernel (função de covariância)
# RBF (Radial Basis Function) + constante para modelar tendências
kernel = C(1.0, (1e-3, 1e3)) * RBF(1.0, (1e-2, 1e2))

# Criando e treinando o processo gaussiano
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)
gp.fit(X_treino, y_treino)

# Fazendo previsões para meses futuros
meses_futuros = np.array([[6], [9], [11], [12]]).reshape(-1, 1)
y_pred, sigma = gp.predict(meses_futuros, return_std=True)

print("\nPrevisões para meses futuros:")
for i, (mes, pred, std) in enumerate(zip(meses_futuros, y_pred, sigma)):
    intervalo_confianca = 1.96 * std  # 95% intervalo de confiança
    print(f"Mês {mes[0]}: R$ {pred:.0f} ± {intervalo_confianca:.0f}")
    print(f"   Faixa provável: R$ {pred - intervalo_confianca:.0f} - R$ {pred + intervalo_confianca:.0f}")

# Visualizando as previsões com incerteza
X_plot = np.linspace(1, 12, 100).reshape(-1, 1)
y_mean, y_std = gp.predict(X_plot, return_std=True)

plt.figure(figsize=(12, 6))
plt.plot(X_treino, y_treino, 'ro', markersize=8, label='Dados históricos')
plt.plot(X_plot, y_mean, 'b-', label='Previsão média')
plt.fill_between(X_plot.ravel(), 
                y_mean - 1.96*y_std, 
                y_mean + 1.96*y_std, 
                alpha=0.2, color='blue', label='95% intervalo de confiança')
plt.xlabel('Mês')
plt.ylabel('Custo de Produção (R$)')
plt.title('Previsão de Custos com Processo Gaussiano')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

"""

Previsão de custos de produção usando Processos Gaussianos

Modela não apenas valores esperados, mas também a incerteza das previsões

"""

import numpy as np

import matplotlib.pyplot as plt

from sklearn.gaussian_process import GaussianProcessRegressor

from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C

# Dados históricos de custos de produção de uma padaria

# [mês, custo_total] - meses consecutivos

X_treino = np.array([[1], [2], [3], [4], [5], [7], [8], [10]]).reshape(-1, 1)

y_treino = np.array([5200, 5400, 5800, 6200, 6500, 7200, 7800, 8500])

print("Dados históricos de custos:")

for i, (mes, custo) in enumerate(zip(X_treino, y_treino)):

print(f"Mês {mes[0]}: R$ {custo}")

# Definindo o kernel (função de covariância)

# RBF (Radial Basis Function) + constante para modelar tendências

kernel = C(1.0, (1e-3, 1e3)) * RBF(1.0, (1e-2, 1e2))

# Criando e treinando o processo gaussiano

gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)

gp.fit(X_treino, y_treino)

# Fazendo previsões para meses futuros

meses_futuros = np.array([[6], [9], [11], [12]]).reshape(-1, 1)

y_pred, sigma = gp.predict(meses_futuros, return_std=True)

print("\nPrevisões para meses futuros:")

for i, (mes, pred, std) in enumerate(zip(meses_futuros, y_pred, sigma)):

intervalo_confianca = 1.96 * std # 95% intervalo de confiança

print(f"Mês {mes[0]}: R$ {pred:.0f} ± {intervalo_confianca:.0f}")

print(f" Faixa provável: R$ {pred - intervalo_confianca:.0f} - R$ {pred + intervalo_confianca:.0f}")

# Visualizando as previsões com incerteza

X_plot = np.linspace(1, 12, 100).reshape(-1, 1)

y_mean, y_std = gp.predict(X_plot, return_std=True)

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

plt.plot(X_treino, y_treino, 'ro', markersize=8, label='Dados históricos')

plt.plot(X_plot, y_mean, 'b-', label='Previsão média')

plt.fill_between(X_plot.ravel(),

y_mean - 1.96*y_std,

y_mean + 1.96*y_std,

alpha=0.2, color='blue', label='95% intervalo de confiança')

plt.xlabel('Mês')

plt.ylabel('Custo de Produção (R$)')

plt.title('Previsão de Custos com Processo Gaussiano')

plt.legend()

plt.grid(True, alpha=0.3)

plt.show()

Os detalhes que fazem diferença

A escolha do kernel é o aspecto mais importante dos processos gaussianos, pois ele define como o modelo entende similaridade entre pontos de dados. O kernel RBF é comum e assume que pontos próximos têm valores similares, mas existem dezenas de opções para diferentes tipos de dados. Contudo, processos gaussianos podem ser computacionalmente caros para grandes conjuntos de dados (complexidade $O(n^3)$), tornando-se impraticáveis acima de alguns milhares de pontos. Analogamente importante é entender que a incerteza capturada pelo modelo reflete apenas a incerteza devido à escassez de dados, não erros de medição ou variabilidade não modelada.

Kernel RBF: Bom para funções suaves e contínuas

Kernel Matérn: Mais flexível que RBF, controla suavidade

Escalabilidade: Limite prático around 1.000-10.000 pontos

Interpretação: Incerteza alta indica necessidade de mais dados

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Quando devo usar processos gaussianos em vez de regressão linear ou random forest?” Excelente questão! Use processos gaussianos quando a quantificação da incerteza for crucial para sua aplicação, ou quando você tiver poucos dados mas de alta qualidade. Uma confusão comum é pensar que a incerteza do processo gaussiano captura todos os tipos de erro – na verdade, ela só modela incerteza devido à escassez de dados. Outra dúvida frequente: “Por que a complexidade computacional é tão alta?” Porque o método envolve inverter matrizes de covariância que crescem com o quadrado do número de pontos.

Para onde ir agora?

Experimente processos gaussianos em problemas onde a incerteza é importante, como previsão de custos, análise de experimentos ou otimização de parâmetros. Comece com o kernel RBF padrão e depois explore outros kernels para diferentes tipos de padrões nos dados. Use a visualização da incerteza para identificar onde coletar mais dados. O momento “aha!” acontece quando você percebe o poder de tomar decisões considerando não apenas o que é mais provável, mas também o que poderia acontecer.

Assuntos relacionados

Para dominar processos gaussianos, estude estes conceitos matemáticos:

Estatística multivariada: distribuições normais multivariadas e covariância

Teoria de probabilidade: processos estocásticos e funções aleatórias

Álgebra linear: matrizes de covariância e decomposição espectral

Teoria de kernels: funções de covariância e espaços de Hilbert

Inferência bayesiana: atualização de crenças com novos dados

Referências que valem a pena

Imagine que você está aprendendo a fazer pão pela primeira vez. Primeiro, você estuda receitas, experimenta diferentes técnicas e ajusta ingredientes – isso é o treinamento. Depois de dominar o processo, quando alguém te entrega farinha, água e fermento, você transforma esses ingredientes em pão fresco – isso é a transformação. No machine learning, esses dois conceitos trabalham juntos: o treinamento ensina o algoritmo a reconhecer padrões, e a transformação aplica esse conhecimento a novos dados.

Como isso funciona na prática?

O treinamento (training) é o processo onde o algoritmo aprende com dados históricos, ajustando seus parâmetros internos para encontrar padrões e relações. Pense nisso como um estudante revisando material antes de uma prova. A transformação (transform) é quando o modelo treinado aplica seu conhecimento a dados novos nunca vistos antes, similar a um estudante usando o que aprendeu para resolver questões da prova. No Scikit-Learn, essa separação é fundamental e segue o padrão consistente: primeiro você chama fit() para treinar, depois transform() ou predict() para aplicar.

Mãos na massa: treinando e transformando dados de receitas

"""
Demonstração completa do ciclo treinamento-transformacao
Aplica PCA para reduzir dimensionalidade de características de receitas
"""

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
import numpy as np

# Dados de receitas: [farinha_g, agua_ml, fermento_g, sal_g, acucar_g]
receitas_treino = np.array([
    [500, 300, 10, 10, 5],    # Pão francês
    [400, 240, 15, 8, 20],    # Pão doce
    [600, 360, 12, 12, 0],    # Pão integral
    [450, 270, 8, 9, 2],      # Pão caseiro
    [350, 210, 20, 7, 25]     # Pão de leite
])

# Novas receitas para transformar (dados nunca vistos)
receitas_novas = np.array([
    [480, 290, 11, 9, 3],     # Nova receita similar
    [550, 330, 9, 11, 1]      # Outra nova receita
])

print("=== FASE 1: TREINAMENTO (fit) ===")
print("Dados de treinamento originais (5 dimensões):")
print(receitas_treino)

# Criando pipeline: normalização + PCA
pipeline = Pipeline([
    ('scaler', StandardScaler()),     # Normaliza os dados
    ('pca', PCA(n_components=2))      # Reduz para 2 dimensões
])

# TREINAMENTO: Aprendendo com os dados de treino
pipeline.fit(receitas_treino)

# Extraindo o PCA treinado para inspecionar
pca_treinado = pipeline.named_steps['pca']
print(f"\nVariância explicada pelos componentes: {pca_treinado.explained_variance_ratio_}")
print(f"Variância total preservada: {sum(pca_treinado.explained_variance_ratio_):.1%}")

print("\n=== FASE 2: TRANSFORMAÇÃO (transform) ===")
print("Aplicando o modelo treinado a novas receitas:")

# TRANSFORMAÇÃO: Aplicando às novas receitas
receitas_transformadas = pipeline.transform(receitas_novas)

print("Novas receitas transformadas (2 dimensões):")
print(receitas_transformadas)

# Verificando a transformação inversa (opcional)
receitas_reconstruidas = pipeline.inverse_transform(receitas_transformadas)
print("\nReconstrução das receitas (com perda de informação):")
print(receitas_reconstruidas)

print("\nDiferença entre original e reconstruído:")
print(receitas_novas - receitas_reconstruidas)

"""

Demonstração completa do ciclo treinamento-transformacao

Aplica PCA para reduzir dimensionalidade de características de receitas

"""

from sklearn.decomposition import PCA

from sklearn.preprocessing import StandardScaler

from sklearn.pipeline import Pipeline

import numpy as np

# Dados de receitas: [farinha_g, agua_ml, fermento_g, sal_g, acucar_g]

receitas_treino = np.array([

[500, 300, 10, 10, 5], # Pão francês

[400, 240, 15, 8, 20], # Pão doce

[600, 360, 12, 12, 0], # Pão integral

[450, 270, 8, 9, 2], # Pão caseiro

[350, 210, 20, 7, 25] # Pão de leite

])

# Novas receitas para transformar (dados nunca vistos)

receitas_novas = np.array([

[480, 290, 11, 9, 3], # Nova receita similar

[550, 330, 9, 11, 1] # Outra nova receita

])

print("=== FASE 1: TREINAMENTO (fit) ===")

print("Dados de treinamento originais (5 dimensões):")

print(receitas_treino)

# Criando pipeline: normalização + PCA

pipeline = Pipeline([

('scaler', StandardScaler()), # Normaliza os dados

('pca', PCA(n_components=2)) # Reduz para 2 dimensões

])

# TREINAMENTO: Aprendendo com os dados de treino

pipeline.fit(receitas_treino)

# Extraindo o PCA treinado para inspecionar

pca_treinado = pipeline.named_steps['pca']

print(f"\nVariância explicada pelos componentes: {pca_treinado.explained_variance_ratio_}")

print(f"Variância total preservada: {sum(pca_treinado.explained_variance_ratio_):.1%}")

print("\n=== FASE 2: TRANSFORMAÇÃO (transform) ===")

print("Aplicando o modelo treinado a novas receitas:")

# TRANSFORMAÇÃO: Aplicando às novas receitas

receitas_transformadas = pipeline.transform(receitas_novas)

print("Novas receitas transformadas (2 dimensões):")

print(receitas_transformadas)

# Verificando a transformação inversa (opcional)

receitas_reconstruidas = pipeline.inverse_transform(receitas_transformadas)

print("\nReconstrução das receitas (com perda de informação):")

print(receitas_reconstruidas)

print("\nDiferença entre original e reconstruído:")

print(receitas_novas - receitas_reconstruidas)

Os detalhes que fazem diferença

O treinamento e a transformação devem sempre usar exatamente o mesmo pré-processamento para garantir consistência. Um erro comum é treinar com dados normalizados e depois transformar dados não normalizados, ou vice-versa. Contudo, o Scikit-Learn oferece pipelines que automatizam essa consistência. Analogamente importante é a separação estrita entre dados de treino e teste; você nunca deve usar informações dos dados de teste durante o treinamento. A ordem das operações também é crucial: primeiro normalizar, depois aplicar transformações mais complexas como PCA. Lembre-se que alguns algoritmos como KNN não têm fase de treinamento tradicional – eles apenas memorizam os dados.

Ordem correta: Sempre treine antes de transformar
Consistência: Use o mesmo pré-processamento em treino e transformação
Pipelines: Automatizam a sequência de operações
Validação: Nunca use dados de teste no treinamento

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Por que não treinar e transformar tudo de uma vez?” Excelente questão! A separação permite que você valide o modelo em dados não vistos durante o treinamento, prevenindo overfitting. Uma confusão comum é entre fit_transform() e fazer fit() seguido de transform() separadamente – são equivalentes, mas o método combinado é mais conveniente para dados de treino. Outra dúvida frequente: “Posso reutilizar um modelo treinado com dados diferentes?” Sim! Uma vez treinado, você pode aplicar o modelo a quantos dados novos quiser, mas não pode retreinar parcialmente – é tudo ou nada.

Para onde ir agora?

Pratique criando pipelines completos com múltiplos passos de transformação. Experimente diferentes sequências: normalização, seleção de características, redução dimensional. Use validação cruzada para garantir que seu pipeline generaliza bem. O momento “aha!” acontece quando você percebe que pipelines robustos tornam seu código mais reproduzível e menos propenso a erros de pré-processamento.

Assuntos relacionados

Para dominar treinamento e transformação, estude estes conceitos:

Estatística: estimação de parâmetros e inferência
Otimização: algoritmos de aprendizado e convergência
Validação de modelos: overfitting, underfitting e generalização
Pré-processamento: normalização, codificação e imputação
Engenharia de features: criação e seleção de características

Previsões com incerteza: como processos gaussianos nos ajudam a tomar decisões melhores

Como isso funciona na prática?

Mãos na massa: prevendo custos de produção com incerteza

Os detalhes que fazem diferença

Perguntas que os iniciantes fazem

Para onde ir agora?

Assuntos relacionados

Referências que valem a pena

Aprendendo e aplicando: como o treinamento e transformação criam modelos inteligentes

Como isso funciona na prática?

Mãos na massa: treinando e transformando dados de receitas

Os detalhes que fazem diferença

Perguntas que os iniciantes fazem

Para onde ir agora?

Assuntos relacionados

Referências que valem a pena