Feature Engineering para Machine Learning: Tecnicas e Perguntas de Entrevista 2026

Feature engineering representa a etapa mais determinante em qualquer projeto de machine learning -- e tambem uma das areas mais cobradas em entrevistas de data science em 2026. A capacidade de transformar dados brutos em features informativas separa modelos mediocres de modelos que geram valor real em producao.

Enquanto algoritmos podem ser trocados com poucas linhas de codigo, a qualidade das features define o teto de performance de qualquer modelo. Dominar as tecnicas de feature engineering demonstra maturidade tecnica e pensamento critico, duas qualidades que recrutadores avaliam diretamente em processos seletivos.

Estrategias de Encoding para Variaveis Categoricas

Variaveis categoricas exigem transformacoes especificas antes de alimentar algoritmos de machine learning. A escolha entre label encoding e one-hot encoding depende da natureza da variavel: ordinais (com ordem natural) e nominais (sem hierarquia) demandam abordagens distintas.

Label encoding atribui inteiros a cada categoria, preservando uma relacao ordinal. Ja o one-hot encoding cria colunas binarias para cada categoria, eliminando qualquer suposicao de ordem. Aplicar label encoding em variaveis nominais e um erro comum que introduz relacoes artificiais no modelo.

# encoding_strategies.py
import pandas as pd
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer

df = pd.DataFrame({
    "size": ["small", "medium", "large", "medium", "small"],
    "color": ["red", "blue", "green", "red", "blue"],
    "price": [10, 25, 40, 22, 12]
})

# Label encoding for ordinal feature (size has natural order)
le = LabelEncoder()
df["size_encoded"] = le.fit_transform(df["size"])  # large=0, medium=1, small=2

# One-hot encoding for nominal feature (color has no order)
ct = ColumnTransformer(
    transformers=[
        ("onehot", OneHotEncoder(drop="first", sparse_output=False), ["color"])
    ],
    remainder="passthrough"  # Keep other columns unchanged
)
result = ct.fit_transform(df[["color", "price"]])
# Produces: color_green, color_red columns (blue dropped as reference)

O parametro drop="first" no OneHotEncoder elimina uma categoria como referencia, evitando multicolinearidade perfeita -- um detalhe que aparece com frequencia em perguntas de entrevista sobre regressao linear.

Feature Scaling: StandardScaler vs MinMaxScaler vs RobustScaler

A escala das features impacta diretamente algoritmos baseados em distancia (KNN, SVM) e otimizacao por gradiente descendente. Tres abordagens principais existem no scikit-learn, cada uma com caracteristicas distintas frente a outliers.

StandardScaler centraliza os dados com media zero e desvio padrao unitario, mas e sensivel a valores extremos. MinMaxScaler comprime os dados no intervalo [0, 1], porem outliers distorcem severamente a distribuicao. RobustScaler utiliza mediana e intervalo interquartil (IQR), isolando o efeito de outliers sobre o nucleo dos dados.

# feature_scaling.py
import numpy as np
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

# Simulated dataset: salary with outliers
data = np.array([[35000], [42000], [55000], [67000], [450000]])  # 450k is an outlier

# StandardScaler: mean=0, std=1 (sensitive to outliers)
standard = StandardScaler().fit_transform(data)
# Result: [-0.72, -0.68, -0.60, -0.53, 2.53] — outlier distorts the scale

# MinMaxScaler: maps to [0, 1] (very sensitive to outliers)
minmax = MinMaxScaler().fit_transform(data)
# Result: [0.0, 0.017, 0.048, 0.077, 1.0] — most values crushed near zero

# RobustScaler: uses median and IQR (robust to outliers)
robust = RobustScaler().fit_transform(data)
# Result: [-0.77, -0.5, 0.0, 0.46, 15.38] — outlier isolated, core data preserved

Em datasets reais com valores salariais ou financeiros, o RobustScaler costuma ser a escolha mais segura. Essa decisao pratica e frequentemente avaliada em entrevistas tecnicas, onde o candidato precisa justificar a escolha do scaler com base no perfil dos dados.

Transformacoes Matematicas para Distribuicoes Assimetricas

Distribuicoes com assimetria positiva (right-skewed) sao extremamente comuns em dados reais -- renda, precos de imoveis, contagens de eventos. Modelos lineares assumem distribuicoes aproximadamente normais, tornando as transformacoes matematicas uma etapa essencial do pre-processamento.

A transformacao logaritmica (log1p) e a abordagem mais simples e eficaz para assimetria positiva. Box-Cox encontra automaticamente o parametro de potencia ideal, mas exige valores estritamente positivos. Yeo-Johnson generaliza Box-Cox para aceitar zeros e valores negativos, sendo a opcao mais versatil.

# skew_transformations.py
import numpy as np
from sklearn.preprocessing import PowerTransformer

# Right-skewed income data (common in real datasets)
income = np.array([[25000], [32000], [41000], [55000], [72000],
                   [150000], [320000], [890000]])

# Log transform: simple, effective for right-skewed data
log_income = np.log1p(income)  # log1p handles zero values safely

# Box-Cox: finds optimal power parameter automatically
pt = PowerTransformer(method="box-cox")  # Requires strictly positive values
income_boxcox = pt.fit_transform(income)
print(f"Optimal lambda: {pt.lambdas_[0]:.3f}")  # Shows learned parameter

# Yeo-Johnson: works with zero and negative values too
pt_yj = PowerTransformer(method="yeo-johnson")
income_yj = pt_yj.fit_transform(income)

Um ponto relevante para entrevistas: ao aplicar log1p no treino, a transformacao inversa (expm1) precisa ser aplicada nas predicoes. Esquecer essa etapa e um erro classico que invalida metricas de avaliacao em regressao. Para aprofundar o entendimento sobre algoritmos de regressao e classificacao, consulte o guia de algoritmos de machine learning.

Metodos de Feature Selection para Reducao de Dimensionalidade

Feature selection elimina variaveis irrelevantes ou redundantes, reduzindo overfitting e acelerando o treinamento. Tres categorias principais existem: metodos de filtro (estatisticos), wrapper (baseados em modelo iterativo) e embedded (selecao integrada ao treinamento).

O teste ANOVA F (SelectKBest) avalia a significancia estatistica de cada feature individualmente -- e rapido, mas ignora interacoes entre variaveis. Regularizacao L1 (Lasso) zera automaticamente os coeficientes de features irrelevantes durante o treinamento, oferecendo selecao e modelagem simultaneas.

# feature_selection.py
from sklearn.datasets import make_classification
from sklearn.feature_selection import (
    SelectKBest, f_classif,  # Filter method
    SequentialFeatureSelector,  # Wrapper method
    SelectFromModel  # Embedded method
)
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LassoCV

# Dataset: 20 features, only 5 are informative
X, y = make_classification(
    n_samples=1000, n_features=20,
    n_informative=5, n_redundant=3, random_state=42
)

# Filter: ANOVA F-test selects top k features by statistical significance
selector_filter = SelectKBest(f_classif, k=8)
X_filtered = selector_filter.fit_transform(X, y)
print(f"Selected features: {selector_filter.get_support(indices=True)}")

# Embedded: L1 regularization (Lasso) zeros out irrelevant feature weights
lasso = LassoCV(cv=5, random_state=42).fit(X, y)
selector_embedded = SelectFromModel(lasso, prefit=True)
X_lasso = selector_embedded.transform(X)
print(f"Lasso kept {X_lasso.shape[1]} features out of {X.shape[1]}")

A combinacao de metodos de filtro (rapidos, para triagem inicial) com metodos embedded (mais precisos, para selecao final) e uma abordagem robusta que demonstra maturidade tecnica em entrevistas. Para praticar perguntas especificas sobre selecao de features, acesse as perguntas de entrevista sobre feature engineering.

Pipelines de Producao com ColumnTransformer

Em ambientes de producao, cada etapa de pre-processamento precisa ser encapsulada em pipelines reprodutiveis. O ColumnTransformer do scikit-learn permite aplicar transformacoes distintas a grupos de colunas (numericas vs categoricas) dentro de um unico objeto serializavel.

A principal vantagem das pipelines e a prevencao de data leakage: quando combinadas com cross_val_score, o fit do scaler e do encoder ocorre apenas nos dados de treino de cada fold, nunca contaminando a validacao. Essa garantia e critica em producao e aparece frequentemente em entrevistas sobre MLOps.

# production_pipeline.py
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score

# Define column groups by type
numeric_features = ["age", "income", "credit_score"]
categorical_features = ["education", "employment_type", "region"]

# Numeric pipeline: impute missing values, then scale
numeric_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),  # Median resists outliers
    ("scaler", StandardScaler())
])

# Categorical pipeline: impute missing, then one-hot encode
categorical_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(handle_unknown="ignore", sparse_output=False))
])

# Combine into a single preprocessor
preprocessor = ColumnTransformer([
    ("num", numeric_pipeline, numeric_features),
    ("cat", categorical_pipeline, categorical_features)
])

# Full pipeline: preprocessing + model in one object
full_pipeline = Pipeline([
    ("preprocessor", preprocessor),
    ("classifier", GradientBoostingClassifier(n_estimators=200, random_state=42))
])

# Cross-validation applies preprocessing correctly within each fold
scores = cross_val_score(full_pipeline, X, y, cv=5, scoring="roc_auc")
print(f"AUC: {scores.mean():.3f} +/- {scores.std():.3f}")

O parametro handle_unknown="ignore" no OneHotEncoder e um detalhe essencial para producao: categorias nao vistas durante o treino sao tratadas como vetores zero, evitando erros em runtime. Esse tipo de detalhe pratico diferencia respostas superficiais de respostas experientes em entrevistas.

Feature Engineering Automatizado com Featuretools

A biblioteca Featuretools automatiza a criacao de features a partir de dados relacionais usando Deep Feature Synthesis (DFS). A partir de tabelas conectadas por chaves estrangeiras, o algoritmo gera automaticamente agregacoes (COUNT, MEAN, MAX, STD) e transformacoes (month, weekday) em multiplos niveis de profundidade.

Essa abordagem e particularmente valiosa em datasets transacionais, onde a relacao entre entidades (clientes, transacoes, produtos) gera dezenas de features informativas que seriam trabalhosas de criar manualmente.

# automated_feature_engineering.py
import featuretools as ft
import pandas as pd

# Define entities from relational tables
customers = pd.DataFrame({
    "customer_id": [1, 2, 3],
    "signup_date": pd.to_datetime(["2024-01-15", "2024-03-22", "2024-06-01"]),
    "region": ["US", "EU", "APAC"]
})

transactions = pd.DataFrame({
    "txn_id": range(1, 8),
    "customer_id": [1, 1, 1, 2, 2, 3, 3],
    "amount": [50, 120, 30, 200, 85, 340, 15],
    "category": ["food", "tech", "food", "tech", "travel", "food", "tech"]
})

# Create an EntitySet with relationships
es = ft.EntitySet(id="retail")
es = es.add_dataframe(dataframe=customers, dataframe_name="customers",
                      index="customer_id", time_index="signup_date")
es = es.add_dataframe(dataframe=transactions, dataframe_name="transactions",
                      index="txn_id")
es = es.add_relationship("customers", "customer_id",
                         "transactions", "customer_id")

# DFS generates features: COUNT, MEAN, MAX, STD of transactions per customer
feature_matrix, feature_defs = ft.dfs(
    entityset=es, target_dataframe_name="customers",
    max_depth=2,  # Controls complexity of generated features
    trans_primitives=["month", "weekday"],  # Transformation primitives
    agg_primitives=["count", "mean", "std", "max"]  # Aggregation primitives
)
print(f"Generated {len(feature_defs)} features from 2 tables")

O parametro max_depth controla a complexidade das features geradas. Profundidade 1 gera agregacoes diretas; profundidade 2 combina transformacoes com agregacoes (por exemplo, "media do valor de transacoes feitas em dias de semana"). Para fundamentos de manipulacao de dados com Pandas e NumPy, consulte o guia de Python para data science.

Perguntas Frequentes de Feature Engineering em Entrevistas 2026

Processos seletivos de data science em 2026 cobram feature engineering tanto em perguntas conceituais quanto em exercicios praticos. As questoes mais recorrentes avaliam a capacidade de tomar decisoes tecnicas justificadas.

"Quando usar one-hot encoding vs label encoding?" -- One-hot encoding e adequado para variaveis nominais (sem ordem), enquanto label encoding aplica-se a variaveis ordinais (com hierarquia natural). Usar label encoding em variaveis nominais forca o modelo a interpretar relacoes numericas inexistentes entre categorias.

"Como lidar com features de alta cardinalidade?" -- One-hot encoding gera dimensionalidade excessiva quando a variavel possui muitas categorias unicas. Alternativas incluem target encoding (media da variavel alvo por categoria), frequency encoding (frequencia de cada categoria) e hashing trick (mapeamento para espaco de dimensao fixa).

"Explique data leakage no contexto de feature engineering." -- Data leakage ocorre quando informacoes do conjunto de teste contaminam o treinamento. O exemplo classico e aplicar StandardScaler.fit_transform no dataset completo antes do split -- a media e o desvio padrao calculados incluem dados de teste. Pipelines do scikit-learn previnem esse problema ao encapsular o fit dentro de cada fold de validacao cruzada.

"Qual a diferenca entre feature selection e feature extraction?" -- Feature selection escolhe um subconjunto das features originais (a informacao permanece interpretavel). Feature extraction cria novas representacoes dos dados (como PCA), potencialmente perdendo interpretabilidade em troca de reducao de dimensionalidade.

"Como decidir entre normalizar ou padronizar features?" -- Padronizacao (StandardScaler) e preferivel quando o algoritmo assume distribuicao normal (regressao linear, regressao logistica). Normalizacao (MinMaxScaler) e adequada quando o algoritmo exige valores em um intervalo fixo (redes neurais com sigmoid, KNN com distancia euclidiana). Quando outliers estao presentes, RobustScaler oferece uma alternativa mais estavel.

Conclusao

Feature engineering continua sendo a competencia tecnica que mais diferencia candidatos em entrevistas de data science em 2026. Os pontos essenciais abordados neste guia:

• Encoding categorico: label encoding para ordinais, one-hot encoding para nominais, com drop="first" para evitar multicolinearidade
• Scaling: escolher entre StandardScaler, MinMaxScaler e RobustScaler com base na presenca de outliers e nas premissas do algoritmo
• Transformacoes de assimetria: log, Box-Cox e Yeo-Johnson para normalizar distribuicoes -- sem esquecer a transformacao inversa nas predicoes
• Feature selection: combinar metodos de filtro (rapidos) com embedded (Lasso) para selecao robusta e interpretavel
• Pipelines de producao: ColumnTransformer com cross-validation para eliminar data leakage e garantir reprodutibilidade
• Automacao com Featuretools: Deep Feature Synthesis para gerar features a partir de dados relacionais, complementando o raciocinio manual sobre o dominio
• Preparacao para entrevistas: justificar cada decisao tecnica com base nas caracteristicas dos dados, nao apenas demonstrar conhecimento de sintaxe