Padronização

O que “padronização (standardization)” significa no aprendizado de máquina (machine learning)

Padronização é uma técnica de escalonamento de atributos (feature scaling) que transforma atributos numéricos para que compartilhem uma escala comum — tipicamente média zero e variância unitária. A forma mais comum é o escore z (z-scoring):

[ z = \frac{x - \mu}{\sigma} ]

onde:

  • (x) é o valor original do atributo
  • (\mu) é a média do atributo (calculada nos dados de treinamento)
  • (\sigma) é o desvio padrão do atributo (calculado nos dados de treinamento)

Após a padronização, cada atributo é medido em “desvios padrão em relação à sua média”. Isso torna atributos com unidades diferentes (por exemplo, dólares vs quilômetros) mais comparáveis e evita que atributos em grande escala dominem algoritmos sensíveis à magnitude.

A padronização é uma das etapas mais comuns dentro do guarda-chuva mais amplo de Escalonamento de Atributos (Feature Scaling). Para um tratamento mais aprofundado e focado em fórmulas do escore z, veja Padronização (Escore z).

Por que a padronização importa

Muitos algoritmos de aprendizado de máquina assumem implicitamente que:

  • cada atributo contribui de forma comparável, ou
  • a geometria dos dados (distâncias, ângulos, variâncias) não deve ser dominada por unidades arbitrárias.

Quando essas suposições são violadas, os modelos podem se comportar mal, treinar lentamente ou aprender padrões enganosos.

Intuição geométrica: distâncias e direções

Considere dois atributos:

  • age em anos (0–100)
  • income em dólares (0–200.000)

Se você executar um modelo baseado em distância como k-vizinhos mais próximos (k-NN), as diferenças de renda dominam a distância Euclidiana (Euclidean distance) simplesmente porque a escala numérica é maior, não porque renda seja inerentemente mais importante.

A padronização torna comparável “uma unidade” em cada dimensão do atributo (um desvio padrão), de modo que cálculos de distância e ângulo reflitam a estrutura, e não as unidades.

Intuição de otimização: treinamento baseado em gradiente fica mais fácil

Para modelos baseados em gradiente (gradient-based) (por exemplo, regressão linear (linear regression)/regressão logística (logistic regression) treinadas com métodos de gradiente, redes neurais (neural networks)), atributos mal escalonados criam um problema de otimização mal condicionado (ill-conditioned optimization problem):

  • os gradientes apontam “íngremes” em algumas direções e “rasos” em outras
  • a superfície de perda (loss surface) fica alongada (“ravinas”)
  • o treinamento pode exigir taxas de aprendizado (learning rates) minúsculas, convergir lentamente ou oscilar

A padronização frequentemente melhora o condicionamento, permitindo um treinamento mais rápido e estável. Isso se conecta de perto a Descida do Gradiente (Gradient Descent) e aos benefícios práticos de gradientes com melhor comportamento.

A regularização (regularization) passa a fazer sentido

Em modelos lineares regularizados (Ridge/Lasso/Elastic Net), a penalidade normalmente depende das magnitudes dos coeficientes (por exemplo, (\lambda \lVert w \rVert^2)). Se os atributos estiverem em escalas diferentes, os tamanhos dos coeficientes não são comparáveis, e o regularizador acaba penalizando alguns atributos mais do que outros.

A padronização torna a regularização mais “justa” entre atributos.

Algoritmos que comumente se beneficiam

PCA e outros métodos baseados em variância

PCA (Análise de Componentes Principais) encontra direções de variância máxima. Se um atributo tem escala numérica maior, ele contribui com mais variância e pode dominar os componentes principais.

  • Se você quer PCA com base em correlações (variação relativa), padronize primeiro.
  • Se a escala absoluta for significativa (por exemplo, medições todas na mesma unidade), você pode optar por não padronizar.

Muitos profissionais padronizam por padrão antes de PCA, a menos que tenham um motivo de domínio para não fazê-lo.

k-vizinhos mais próximos, k-médias (k-means) e métodos baseados em distância

  • k-vizinhos mais próximos depende das distâncias até os vizinhos.
  • k-médias minimiza distâncias dentro dos clusters.
  • Muitos métodos de agrupamento e similaridade se comportam de forma semelhante.

A padronização geralmente é essencial; caso contrário, atributos com escalas maiores dominam.

SVMs com núcleos RBF (RBF kernels) ou polinomiais (polynomial kernels)

SVMs (máquinas de vetores de suporte) com kernel usam distâncias no espaço de atributos. Escalas desiguais podem afetar fortemente os valores do kernel e as fronteiras de decisão, tornando a padronização um padrão comum em pipelines de SVM.

Modelos lineares e redes neurais baseados em gradiente

Modelos treinados via gradientes normalmente se beneficiam da padronização:

  • regressão logística / regressão linear (especialmente com regularização)
  • perceptrons multicamadas (multilayer perceptrons) e outras redes neurais (distintos de mecanismos internos como normalização em lote (batch normalization))

Mesmo ao usar otimizadores adaptativos (adaptive optimizers), a padronização de atributos frequentemente melhora estabilidade e velocidade.

Quando muitas vezes é *menos* importante: modelos baseados em árvores (tree-based models)

Árvores de decisão (decision trees) e ensembles de árvores (florestas aleatórias (random forests), árvores com boosting de gradiente (gradient-boosted trees)) são em grande medida invariantes a transformações monotônicas (monotonic transformations) de atributos individuais e não dependem de distâncias. A padronização geralmente não é necessária para desempenho, embora ainda possa ser útil para:

  • combinar com outros tipos de modelo em um pipeline
  • melhorar a estabilidade numérica em algumas implementações
  • consistência de interpretabilidade entre experimentos

Padronização vs normalização (normalization) vs escalonamento min–max (min–max scaling)

Esses termos são frequentemente confundidos, então ajuda ser preciso.

Padronização (escalonamento por escore z)

Transforma cada atributo para ter:

  • média ≈ 0
  • desvio padrão ≈ 1

Prós:

  • funciona bem para muitos algoritmos
  • mantém outliers (não os “corta”), mas reduz seu domínio em relação à escala bruta
  • preserva relações lineares (transformação afim (affine transform))

Contras:

  • sensível a outliers porque média e desvio padrão não são estatísticas robustas
  • não limita os valores a um intervalo fixo

Escalonamento min–max (reescalonamento para um intervalo)

Uma alternativa comum reescala cada atributo para ([0,1]):

[ x' = \frac{x - x_{\min}}{x_{\max} - x_{\min}} ]

Prós:

  • intervalo limitado, útil para modelos que esperam entradas restritas (algumas configurações de redes neurais)
  • preserva a ordenação relativa

Contras:

  • altamente sensível a outliers (um valor extremo comprime o restante)
  • o intervalo depende dos dados de treinamento; deriva/valores fora de faixa no teste podem produzir valores fora de ([0,1])

“Normalização” (escalonamento para norma unitária)

Em muitos contextos de aprendizado de máquina, normalização significa escalonar cada vetor de amostra (sample vector) para ter norma unitária:

[ x' = \frac{x}{\lVert x \rVert} ]

Isso é comum em recuperação de texto (text retrieval) (vetores TF-IDF) e em pipelines de similaridade do cosseno (cosine similarity). Ela responde a uma pergunta diferente: “tornar cada exemplo com comprimento comparável”, em vez de “tornar cada atributo comparável entre exemplos”.

Qual você deve usar?

Uma regra prática:

  • Use padronização para:

    • PCA
    • k-vizinhos mais próximos / k-médias
    • SVMs
    • modelos lineares regularizados
    • muitos modelos baseados em gradiente

  • Use escalonamento min–max quando:

    • seu modelo ou domínio se beneficia de entradas limitadas (por exemplo, algumas configurações de redes neurais)
    • distribuições de atributos são estáveis e outliers são tratados

  • Use normalização por norma unitária quando:

    • similaridade do cosseno é a noção correta de similaridade
    • invariância ao comprimento do documento importa (comum em espaços vetoriais de PLN (NLP))

Em fluxos de trabalho reais, você pode combiná-las (por exemplo, padronizar alguns atributos contínuos e normalizar vetores esparsos de texto).

Variantes comuns de padronização

Apenas centralização na média

Às vezes você subtrai a média, mas não escala pela variância:

[ x' = x - \mu ]

Isso é especialmente comum quando você quer remover deslocamentos (por exemplo, para alguns métodos de álgebra linear), mas manter as unidades originais.

Padronização robusta

Quando há muitos outliers, você pode usar estatísticas robustas:

  • centralizar pela mediana
  • escalar pelo intervalo interquartil (IQR)

Isso costuma ser chamado de “escalonamento robusto (robust scaling)” e pode produzir modelos mais estáveis quando as distribuições têm caudas extremas.

Branqueamento (whitening) (mais do que padronização)

A padronização escala atributos de forma independente. Branqueamento vai além e remove correlações entre atributos (por exemplo, usando a raiz quadrada inversa da matriz de covariância). O branqueamento às vezes é usado antes de Análise de Componentes Independentes (ICA) ou em certos contextos de processamento de sinais (signal processing), mas pode amplificar ruído e não é uma escolha padrão para a maioria da modelagem preditiva.

Padronização por grupo (escalonamento consciente de grupos)

Em alguns cenários, você deve padronizar dentro de grupos (por exemplo, por usuário, por dispositivo, por site) se os grupos tiverem baselines diferentes. Isso pode ser útil, mas também é um lugar comum para introduzir acidentalmente vazamento de dados (leakage) se os grupos se sobrepuserem entre treino/teste de maneiras problemáticas.

Exemplos práticos

Exemplo 1: Por que k-vizinhos mais próximos precisa de escalonamento

Suponha que temos dois atributos: height_cm e annual_income.

  • alturas variam em ~20–30 cm entre adultos
  • rendas variam em dezenas de milhares

A distância Euclidiana entre duas pessoas será dominada por diferenças de renda, mesmo que altura seja de fato preditiva para sua tarefa.

A padronização faz diferença porque compara cada atributo em unidades de desvio padrão, então “altura incomum” pode importar tanto quanto “renda incomum” se ambas forem igualmente informativas.

Exemplo 2: StandardScaler no scikit-learn

import numpy as np
from sklearn.preprocessing import StandardScaler

X_train = np.array([
    [160,  40000],
    [170,  60000],
    [180, 120000],
], dtype=float)

X_test = np.array([
    [175,  50000],
], dtype=float)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)  # fit on train only
X_test_scaled = scaler.transform(X_test)        # transform test using train stats

print("train mean:", scaler.mean_)
print("train std:", scaler.scale_)
print("scaled test:", X_test_scaled)

Pontos-chave:

  • fit_transform aprende (\mu) e (\sigma) a partir dos dados de treinamento.
  • transform aplica a mesma transformação aos dados de validação/teste.

Exemplo 3: Escalonamento correto dentro de um pipeline (pipeline) (evitando vazamento de dados)

O escalonamento precisa ser feito dentro do laço de treinamento para validação cruzada (cross-validation). Caso contrário, você usa acidentalmente informações das dobras de validação para calcular média/desvio padrão (uma forma de vazamento).

Usar um pipeline evita isso:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("clf", LogisticRegression(max_iter=1000))
])

scores = cross_val_score(pipe, X_train, y_train, cv=5)
print(scores.mean())

Isso é fortemente relacionado a Vazamento de Dados e às boas práticas descritas em Pipelines (Pré-processamento de AM + Modelagem).

Armadilhas e boas práticas

1) Vazamento de dados: ajustar no conjunto completo

Errado: calcular média/desvio padrão no conjunto completo antes de dividir.

Por que é errado:

  • permite que informações do conjunto de teste influenciem a transformação do treinamento
  • pode inflar métricas offline e falhar em produção

Boa prática:

  • divida primeiro
  • ajuste escalonadores apenas nos dados de treinamento
  • aplique em validação/teste com os mesmos parâmetros ajustados

2) Consistência entre treino/teste (e salvar o escalonador)

Em produção, você deve aplicar a exata mesma transformação aprendida durante o treinamento. Isso significa que você precisa de:

  • as médias e desvios padrão do treinamento
  • a ordem dos atributos e a lógica de pré-processamento

Boa prática:

  • serializar o pipeline inteiro (pré-processamento + modelo), não apenas os pesos do modelo

3) Tipos de atributos mistos: não escalone tudo cegamente

  • Atributos codificados one-hot (one-hot encoded) (0/1) muitas vezes não precisam de padronização, e escaloná-los pode mudar a interpretação e a regularização relativa.
  • Contagens podem se beneficiar de transformações logarítmicas ou outro tratamento específico do domínio antes do escalonamento.
  • Indicadores binários (binary flags) frequentemente devem permanecer como estão.

Uma abordagem comum: aplicar padronização apenas a colunas numéricas contínuas, deixando colunas categóricas one-hot intocadas (ou usando um ramo de pré-processamento separado).

Isso normalmente usa um transformador por coluna (por exemplo, ColumnTransformer no scikit-learn).

4) Outliers podem distorcer média/desvio padrão

Como média e desvio padrão são sensíveis a outliers, alguns valores extremos podem causar:

  • a maior parte dos dados colapsar em um intervalo padronizado estreito
  • comportamento instável do modelo

Mitigações:

  • usar escalonamento robusto (mediana/IQR)
  • recortar (clip)/winsorizar (winsorize) outliers
  • aplicar uma transformação monotônica (monotonic transform) (por exemplo, log) antes de padronizar

5) Atributos com variância quase zero

Se um atributo tem (quase) variância zero, (\sigma \approx 0), a padronização se torna numericamente instável.

Tratamento comum:

  • remover atributos constantes/quase constantes
  • adicionar salvaguardas com pequeno épsilon (epsilon) (a maioria das bibliotecas lida com isso)
  • tratar como categórico/binário, se apropriado

6) Séries temporais (time series) e dados em streaming (streaming)

Para séries temporais, o escalonamento deve respeitar a ordem temporal:

  • ajustar o escalonador apenas com dados passados
  • evitar usar observações futuras para calcular média/desvio padrão

Em cenários de streaming, você pode precisar de estimativas incrementais/online de média e variância, e deve considerar deriva de conceito (concept drift) (a “média/desvio padrão corretos” podem mudar ao longo do tempo).

7) Mudanças de interpretação

A padronização altera a interpretação dos coeficientes em modelos lineares:

  • coeficientes correspondem a uma mudança de um desvio padrão no atributo, não a uma mudança de uma unidade

Isso pode até melhorar a interpretabilidade (comparando tamanhos de efeito entre atributos), mas é importante comunicar o que “uma unidade” significa após o escalonamento.

8) Valores ausentes devem ser tratados primeiro

A maioria das implementações de padronização não lida com NaNs como pretendido. Em geral, você deve fazer Imputação (Imputation) (Tratamento de Valores Ausentes) antes do escalonamento e garantir que a própria imputação seja ajustada apenas nos dados de treinamento.

Quando você *não* deve padronizar

A padronização é frequentemente benéfica, mas não universal:

  • Se os atributos já são comensuráveis e estão em unidades compartilhadas significativas, o escalonamento pode ser desnecessário.
  • Se seu modelo é invariante à escala (muitos métodos baseados em árvores), o escalonamento geralmente não ajudará.
  • Se a escala original carrega significado de domínio que você quer preservar (por exemplo, unidades físicas usadas em restrições downstream), considere alternativas ou escale apenas atributos selecionados.
  • Se você está trabalhando com vetores esparsos de alta dimensionalidade (sparse high-dimensional vectors) (como saco de palavras (bag-of-words)), a padronização pode densificar os dados e aumentar o uso de memória; a normalização por norma unitária é mais comum nesse caso.

Um checklist prático de decisão

Use padronização quando qualquer uma das condições a seguir for verdadeira:

  • você usa distâncias, produtos escalares (dot products) ou ângulos diretamente (k-vizinhos mais próximos, k-médias, kernels de SVM)
  • você usa PCA ou outros métodos baseados em variância/covariância
  • você treina com métodos baseados em gradiente e vê treinamento lento/instável
  • você usa regularização entre atributos heterogêneos

Tenha cautela quando:

  • você tem outliers fortes (considere escalonamento robusto)
  • você tem dependência temporal (ajuste apenas no passado)
  • você corre risco de vazamento (sempre escale dentro de CV/pipelines)
  • você tem tipos de atributo mistos (escale contínuos, não tudo)

Resumo

A padronização é uma etapa fundamental de pré-processamento que reescala atributos numéricos — mais comumente via escore z — para ter média e variância comparáveis. Ela importa porque muitos algoritmos são sensíveis às magnitudes dos atributos, afetando cálculos de distância, decomposições baseadas em variância como PCA e o condicionamento da otimização baseada em gradiente. A escolha entre padronização, escalonamento min–max e normalização depende do modelo e da geometria dos dados que você considera relevante. Na prática, os maiores erros são vazamento (ajustar o escalonador em dados que não são de treinamento) e inconsistência (não aplicar a transformação idêntica no tempo de inferência (inference time)), ambos melhor resolvidos com pré-processamento ponta a ponta via Pipelines (Pré-processamento de AM + Modelagem).