Engenharia de Features

A engenharia de features transforma colunas brutas em representações que os modelos podem aprender. Codificar categóricas, escalar numéricas e compor transformações com ColumnTransformer são os padrões centrais para ML tabular.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier
 
preprocessor = ColumnTransformer([
    ("num", StandardScaler(), numeric_cols),
    ("cat", OneHotEncoder(handle_unknown="ignore"), categorical_cols),
])
pipe = Pipeline([("prep", preprocessor), ("clf", RandomForestClassifier())])

Quando usar isso:

• Colunas numéricas e categóricas mistas no mesmo conjunto de dados.
• Modelos sensíveis à escala das features (SVM, regressão logística, redes neurais em dados tabulares).
• Categóricas de alta cardinalidade que necessitam de hashing ou codificação de destino (target encoding).
• Pré-processamento reproduzível, agrupado com o modelo para implantação.

Exemplo de Trabalho

"""feature_engineering.py - pré-processamento de tipos mistos com ColumnTransformer."""
from __future__ import annotations
 
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
 
df = pd.DataFrame({
    "age": [25, 34, 45, 29, 52],
    "income": [45000, 62000, 88000, 51000, 95000],
    "city": ["nyc", "la", "nyc", "chicago", "la"],
    "plan": ["basic", "pro", "pro", "basic", "enterprise"],
    "churned": [0, 0, 1, 0, 1],
})
 
X = df.drop(columns=["churned"])
y = df["churned"]
numeric_cols = ["age", "income"]
categorical_cols = ["city", "plan"]
 
preprocessor = ColumnTransformer(
    transformers=[
        ("num", StandardScaler(), numeric_cols),
        ("cat", OneHotEncoder(handle_unknown="ignore", sparse_output=False), categorical_cols),
    ],
    remainder="drop",
)
 
pipe = Pipeline([
    ("prep", preprocessor),
    ("clf", GradientBoostingClassifier(random_state=42)),
])
 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=42)
pipe.fit(X_train, y_train)
print(classification_report(y_test, pipe.predict(X_test)))

O que isso demonstra:

• Diferentes transformações aplicadas a grupos de colunas numéricas e categóricas.
• OneHotEncoder com handle_unknown="ignore" para segurança em produção.
• sparse_output=False para saída densa compatível com modelos de árvore e lineares.
• Serialização completa do pipeline - o pré-processamento acompanha o classificador.

Mergulho Profundo

Como Funciona

• Escalonamento centraliza e escala colunas numéricas para que modelos baseados em gradiente convirjam mais rapidamente.
• Codificação one-hot expande categóricas em colunas indicadoras binárias por categoria.
• ColumnTransformer executa cada sub-transformador em suas colunas designadas e concatena os resultados.
• Pipelines chamam fit em dados de treinamento por fold de CV, prevenindo vazamento de estatísticas.
• Nomes de features podem ser recuperados com get_feature_names_out() após o ajuste.

Transformações Comuns

Notas Python

from sklearn.preprocessing import FunctionTransformer
import numpy as np
 
log_transform = FunctionTransformer(np.log1p, validate=False)
# Encadear imputação antes do escalonamento no ramo numérico:
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline as SkPipeline
 
numeric_pipe = SkPipeline([
    ("impute", SimpleImputer(strategy="median")),
    ("scale", StandardScaler()),
])

Armadilhas

• Ajustar em dados completos - calcular média/std ou listas de categorias a partir de linhas de teste vaza informações. Correção: ajustar dentro de um pipeline apenas em folds de treinamento.
• Categorias não vistas na inferência - novos valores de categoria travam um OneHotEncoder simples. Correção: handle_unknown="ignore" ou handle_unknown="infrequent_if_exist".
• Vazamento de codificação de destino (target encoding) - codificar categorias com a média do destino usando todos os dados infla as pontuações de CV. Correção: usar TargetEncoder dentro de um pipeline com CV adequado.
• Escalonamento desnecessário para modelos de árvore - florestas aleatórias e gradient boosting são invariantes à escala. Correção: pular o escalonamento para ensembles de árvores; ainda codificar categóricas.
• One-hot de alta cardinalidade - milhares de colunas dummy desaceleram o treinamento e causam overfitting. Correção: hashing (FeatureHasher), codificação de frequência ou embeddings.
• Explosão polinomial - PolynomialFeatures(degree=3) em 20 colunas cria milhares de features. Correção: limitar o grau, usar seleção de features ou modo apenas de interação.

Alternativas

FAQs

pipe.fit(X_train, y_train)
names = pipe.named_steps["prep"].get_feature_names_out()
print(list(names))

from sklearn.impute import SimpleImputer
num_pipe = Pipeline([("impute", SimpleImputer(strategy="median")), ("scale", StandardScaler())])

df["order_year"] = df["order_date"].dt.year
df["order_dow"] = df["order_date"].dt.dayofweek

Xt = preprocessor.fit_transform(X_train)
print(Xt.shape)  # linhas x total de features codificadas

Relacionados

• Pipelines - encadeando transformações e modelos
• Datasets & Divisões - ajustar transformações apenas em treino
• Aprendizado Supervisionado - necessidades de pré-processamento específicas do modelo
• Dados Desbalanceados - reamostragem dentro de pipelines
• Gradient Boosting - modelos de árvore e categóricas

Versões da Stack: Esta página foi escrita para Python 3.14.0 (stable 3.14, maintenance 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, e uv 0.6+.