antonino, Autor em Área de Trampo

Categorias

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

Referências que valem a pena

Imagine que você é um treinador de futebol avaliando novos jogadores. Dois atletas estão à mesma distância física de você, mas um está dentro do campo e outro está na arquibancada. A distância euclidiana diria que estão igualmente próximos, mas seu instinto sabe que o jogador no campo está muito mais “perto” do contexto do futebol. A distância de Mahalanobis é como esse instinto treinado – ela considera a distribuição e correlação dos dados para medir distâncias de forma mais inteligente e contextual.

Como isso funciona na prática?

A distância de Mahalanobis vai beyond da simples geometria ao considerar a estrutura de covariância dos dados. Enquanto a distância euclidiana mede distâncias “em linha reta”, a Mahalanobis mede distâncias em termos de desvios padrão da distribuição. Ela automaticamente leva em conta que algumas direções nos dados são mais variáveis que outras, e que características podem estar correlacionadas. Na implementação do Scikit-Learn, essa sofisticação matemática é encapsulada em interfaces simples, permitindo que você use métricas avançadas com a mesma facilidade das básicas.

Mãos na massa: implementando a distância de Mahalanobis no Scikit-Learn

"""
Implementação da distância de Mahalanobis e comparação com outras métricas
Demonstra detecção de outliers e classificação com distâncias inteligentes
"""

import numpy as np
from sklearn.neighbors import NearestNeighbors
from sklearn.covariance import EmpiricalCovariance
from scipy.spatial.distance import mahalanobis
import matplotlib.pyplot as plt

# Gerando dados de jogadores de futebol correlacionados
# [altura_cm, peso_kg, velocidade_kmh] - características naturalmente correlacionadas
np.random.seed(42)
n_jogadores = 100

# Criando dados com correlação entre altura e peso
alturas = np.random.normal(180, 8, n_jogadores)
pesos = alturas * 0.4 + np.random.normal(70, 5, n_jogadores)  # Peso correlacionado com altura
velocidades = np.random.normal(32, 3, n_jogadores)

dados_jogadores = np.column_stack([alturas, pesos, velocidades])

# Calculando a matriz de covariância para a distância de Mahalanobis
covariancia = EmpiricalCovariance().fit(dados_jogadores)
matriz_covariancia = covariancia.covariance_
inversa_covariancia = np.linalg.inv(matriz_covariancia)

print("Matriz de covariância dos dados:")
print(matriz_covariancia)

# Calculando distância de Mahalanobis manualmente
def distancia_mahalanobis_manual(x, y, inv_cov):
    """Implementação manual da fórmula: √((x-y)ᵀ × Σ⁻¹ × (x-y))"""
    diferenca = x - y
    return np.sqrt(diferenca.T @ inv_cov @ diferenca)

# Testando com um jogador médio e um outlier
jogador_medio = np.mean(dados_jogadores, axis=0)
jogador_outlier = np.array([160, 90, 25])  # Baixo, pesado, lento - padrão incomum

# Comparando diferentes distâncias
dist_euclidiana = np.linalg.norm(jogador_medio - jogador_outlier)
dist_mahalanobis_manual = distancia_mahalanobis_manual(jogador_medio, jogador_outlier, inversa_covariancia)
dist_mahalanobis_scipy = mahalanobis(jogador_medio, jogador_outlier, inversa_covariancia)

print(f"\nComparação de distâncias para o jogador outlier:")
print(f"Distância Euclidiana: {dist_euclidiana:.2f}")
print(f"Distância Mahalanobis (manual): {dist_mahalanobis_manual:.2f}")
print(f"Distância Mahalanobis (SciPy): {dist_mahalanobis_scipy:.2f}")

# Usando NearestNeighbors com métrica personalizada (implementação prática)
def mahalanobis_metric(x, y, VI=inversa_covariancia):
    """Métrica personalizada para usar com NearestNeighbors"""
    diferenca = x - y
    return np.sqrt(diferenca @ VI @ diferenca)

vizinhos = NearestNeighbors(n_neighbors=5, metric=mahalanobis_metric)
vizinhos.fit(dados_jogadores)

# Encontrando vizinhos mais próximos usando Mahalanobis
distancias, indices = vizinhos.kneighbors(jogador_medio.reshape(1, -1))
print(f"\nVizinhos mais próximos do jogador médio (Mahalanobis): {indices[0]}")

"""

Implementação da distância de Mahalanobis e comparação com outras métricas

Demonstra detecção de outliers e classificação com distâncias inteligentes

"""

import numpy as np

from sklearn.neighbors import NearestNeighbors

from sklearn.covariance import EmpiricalCovariance

from scipy.spatial.distance import mahalanobis

import matplotlib.pyplot as plt

# Gerando dados de jogadores de futebol correlacionados

# [altura_cm, peso_kg, velocidade_kmh] - características naturalmente correlacionadas

np.random.seed(42)

n_jogadores = 100

# Criando dados com correlação entre altura e peso

alturas = np.random.normal(180, 8, n_jogadores)

pesos = alturas * 0.4 + np.random.normal(70, 5, n_jogadores) # Peso correlacionado com altura

velocidades = np.random.normal(32, 3, n_jogadores)

dados_jogadores = np.column_stack([alturas, pesos, velocidades])

# Calculando a matriz de covariância para a distância de Mahalanobis

covariancia = EmpiricalCovariance().fit(dados_jogadores)

matriz_covariancia = covariancia.covariance_

inversa_covariancia = np.linalg.inv(matriz_covariancia)

print("Matriz de covariância dos dados:")

print(matriz_covariancia)

# Calculando distância de Mahalanobis manualmente

def distancia_mahalanobis_manual(x, y, inv_cov):

"""Implementação manual da fórmula: √((x-y)ᵀ × Σ⁻¹ × (x-y))"""

diferenca = x - y

return np.sqrt(diferenca.T @ inv_cov @ diferenca)

# Testando com um jogador médio e um outlier

jogador_medio = np.mean(dados_jogadores, axis=0)

jogador_outlier = np.array([160, 90, 25]) # Baixo, pesado, lento - padrão incomum

# Comparando diferentes distâncias

dist_euclidiana = np.linalg.norm(jogador_medio - jogador_outlier)

dist_mahalanobis_manual = distancia_mahalanobis_manual(jogador_medio, jogador_outlier, inversa_covariancia)

dist_mahalanobis_scipy = mahalanobis(jogador_medio, jogador_outlier, inversa_covariancia)

print(f"\nComparação de distâncias para o jogador outlier:")

print(f"Distância Euclidiana: {dist_euclidiana:.2f}")

print(f"Distância Mahalanobis (manual): {dist_mahalanobis_manual:.2f}")

print(f"Distância Mahalanobis (SciPy): {dist_mahalanobis_scipy:.2f}")

# Usando NearestNeighbors com métrica personalizada (implementação prática)

def mahalanobis_metric(x, y, VI=inversa_covariancia):

"""Métrica personalizada para usar com NearestNeighbors"""

diferenca = x - y

return np.sqrt(diferenca @ VI @ diferenca)

vizinhos = NearestNeighbors(n_neighbors=5, metric=mahalanobis_metric)

vizinhos.fit(dados_jogadores)

# Encontrando vizinhos mais próximos usando Mahalanobis

distancias, indices = vizinhos.kneighbors(jogador_medio.reshape(1, -1))

print(f"\nVizinhos mais próximos do jogador médio (Mahalanobis): {indices[0]}")

Os detalhes que fazem diferença

A grande vantagem da distância de Mahalanobis é sua capacidade de lidar com dados correlacionados e de diferentes escalas naturalmente. Enquanto com distâncias euclidianas você precisaria normalizar os dados manualmente, a Mahalanobis faz isso automaticamente através da matriz de covariância. Contudo, essa sofisticação vem com um custo computacional maior e a necessidade de estimar reliably a matriz de covariância. Analogamente importante é entender que a Mahalanobis assume uma distribuição aproximadamente normal multivariada; com distribuições muito assimétricas ou multimodais, seu desempenho pode degradar.

Melhor uso: Dados correlacionados com distribuição aproximadamente normal
Vantagem principal: Considera automaticamente escalas e correlações
Limitação: Sensível a estimativas ruins da matriz de covariância
Implementação: Use EmpiricalCovariance para estimativa robusta

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Quando devo usar Mahalanobis em vez de Euclidiana?” Excelente questão! Use Mahalanobis quando suas características estiverem em escalas diferentes e/ou correlacionadas, especialmente para detecção de outliers. Uma confusão comum é pensar que Mahalanobis sempre performa melhor – na verdade, com dados não correlacionados e bem normalizados, Euclidiana pode ser suficiente e mais rápida. Outra dúvida frequente: “Como a implementação no Scikit-Learn lida com matrizes de covariância singulares?” Ela usa técnicas de regularização para evitar problemas numéricos, mas é sempre bom verificar a qualidade da sua estimativa de covariância.

Para onde ir agora?

Experimente usar a distância de Mahalanobis em seus próprios dados esportivos ou de outras áreas. Comece comparando resultados com Euclidiana e observe as diferenças. Implemente uma métrica personalizada no NearestNeighbors para problemas específicos. O momento “aha!” acontece quando você vê a Mahalanobis identificando padrões e outliers que passariam despercebidos com outras métricas.

Assuntos relacionados

Para dominar a distância de Mahalanobis, estude estes conceitos matemáticos:

Estatística multivariada: covariância, correlação e distribuições normais
Álgebra linear: matrizes, inversas e formas quadráticas
Geometria: elipsoides e transformações de escala
Teoria da probabilidade: distribuições conjuntas e condicionais
Otimização: minimização de distâncias em espaços transformados

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

Medindo distâncias inteligentes: como a distância de Mahalanobis vê o que outras métricas ignoram

Como isso funciona na prática?

Mãos na massa: implementando a distância de Mahalanobis no Scikit-Learn

Os detalhes que fazem diferença

Perguntas que os iniciantes fazem

Para onde ir agora?

Assuntos relacionados

Referências que valem a pena