Top 25 Perguntas de Entrevista de Data Science em 2026

As entrevistas para posições de data scientist em 2026 avaliam muito mais do que definições de livro texto. As equipes de contratação investigam o raciocínio estatístico dos candidatos, as trocas envolvidas em feature engineering, a capacidade de avaliar modelos além da acurácia e a habilidade de traduzir problemas de negócio em pipelines analíticos. Este guia cobre 25 perguntas que aparecem repetidamente em entrevistas de data scientist em empresas que vão desde startups até grandes corporações de tecnologia.

Fundamentos de Probabilidade e Estatística

P1: Uma moeda é jogada 10 vezes e cai cara 8 vezes. A moeda é viciada?

A resposta ingênua é "sim", mas a abordagem rigorosa aplica um teste binomial. Sob a hipótese nula (moeda justa, p=0,5), a probabilidade de obter 8 ou mais caras em 10 lançamentos é aproximadamente 5,5% — valor que não fica abaixo do limiar padrão de 5% de significância. A moeda não pode ser declarada viciada com alpha = 0,05.

# binomial_test.py
from scipy import stats

# Two-sided binomial test: is the coin fair?
result = stats.binomtest(k=8, n=10, p=0.5, alternative='two-sided')
print(f"p-value: {result.pvalue:.4f}")  # 0.1094 (two-sided)
print(f"Reject H0 at alpha=0.05? {result.pvalue < 0.05}")  # False

Essa pergunta testa se os candidatos recorrem à intuição ou aplicam testes de hipótese formais. Os entrevistadores costumam perguntar na sequência sobre erros do Tipo I e Tipo II e qual tamanho de amostra seria necessário para detectar um viés de p=0,7 com 80% de poder estatístico.

P2: Explique a diferença entre as abordagens bayesiana e frequentista de inferência.

A inferência frequentista trata os parâmetros como fixos, porém desconhecidos. Um intervalo de confiança de 95% significa: se o experimento fosse repetido muitas vezes, 95% dos intervalos calculados conteriam o verdadeiro parâmetro. A inferência bayesiana trata os parâmetros como variáveis aleatórias com distribuições a priori, atualizando as crenças por meio do teorema de Bayes para produzir distribuições posteriores. Um intervalo de credibilidade de 95% significa: dado os dados observados e o prior, há 95% de probabilidade de o parâmetro estar nesse intervalo.

# bayesian_vs_frequentist.py
import numpy as np
from scipy import stats

# Frequentist: confidence interval for a mean
data = np.array([23.1, 25.4, 22.8, 24.9, 23.7, 25.1, 24.3])
ci = stats.t.interval(0.95, df=len(data)-1, loc=np.mean(data), scale=stats.sem(data))
print(f"95% CI (frequentist): [{ci[0]:.2f}, {ci[1]:.2f}]")

# Bayesian: posterior with conjugate prior (Normal-Normal)
prior_mean, prior_var = 24.0, 4.0  # prior belief
data_mean, data_var = np.mean(data), np.var(data, ddof=1) / len(data)
# Posterior parameters (conjugate update)
post_var = 1 / (1/prior_var + 1/data_var)
post_mean = post_var * (prior_mean/prior_var + data_mean/data_var)
post_ci = stats.norm.interval(0.95, loc=post_mean, scale=np.sqrt(post_var))
print(f"95% credible interval (Bayesian): [{post_ci[0]:.2f}, {post_ci[1]:.2f}]")

A diferença prática importa nas entrevistas: os métodos bayesianos incorporam conhecimento de domínio por meio de priors, o que é valioso quando os dados são escassos. Os métodos frequentistas fazem menos suposições, mas exigem amostras maiores para uma inferência confiável.

P3: Quando o Teorema Central do Limite falha e por que isso importa para data science?

O TCL garante que as médias amostrais convergem para uma distribuição normal à medida que n cresce — mas apenas quando a população tem variância finita. Distribuições de cauda pesada (Cauchy, Pareto com alpha menor ou igual a 2) violam essa suposição. Na prática, isso afeta a modelagem de retornos financeiros, análise de tráfego de rede e qualquer domínio com outliers extremos. A mediana ou a média aparada torna-se um estimador mais robusto nesses casos.

Feature Engineering e Preparação de Dados

P4: Como os valores ausentes impactam o treinamento de modelos e quais estratégias existem além da imputação simples?

Os mecanismos de dados ausentes determinam a estratégia correta. MCAR (Missing Completely At Random) permite a exclusão listwise sem viés. MAR (Missing At Random) se beneficia de imputação múltipla ou abordagens baseadas em modelos. MNAR (Missing Not At Random) exige a modelagem específica de domínio do próprio mecanismo de ausência.

# missing_data_strategies.py
import pandas as pd
from sklearn.impute import KNNImputer, SimpleImputer
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer

df = pd.DataFrame({
    'age': [25, 30, None, 45, None, 38],
    'income': [50000, None, 70000, 90000, 60000, None],
    'score': [85, 90, 78, None, 88, 92]
})

# Strategy 1: KNN imputation (preserves local structure)
knn_imp = KNNImputer(n_neighbors=2)
df_knn = pd.DataFrame(knn_imp.fit_transform(df), columns=df.columns)

# Strategy 2: Iterative imputation (MICE-like, models each feature)
iter_imp = IterativeImputer(max_iter=10, random_state=42)
df_iter = pd.DataFrame(iter_imp.fit_transform(df), columns=df.columns)

# Strategy 3: Add missingness indicator (preserves signal in the pattern)
df['income_missing'] = df['income'].isna().astype(int)
print(df_knn.round(1))

O insight-chave que os entrevistadores buscam: o padrão de ausência em si pode ser informativo. Adicionar colunas indicadoras binárias para features ausentes frequentemente melhora o desempenho do modelo, especialmente em árvores com gradient boosting.

P5: Explique target encoding e quando ele supera o one-hot encoding.

O one-hot encoding cria uma coluna binária esparsa por categoria. Para features de alta cardinalidade (CEPs, IDs de usuários, SKUs de produtos), isso explode a dimensionalidade. O target encoding substitui cada categoria pela média da variável alvo para aquela categoria, produzindo uma única coluna numérica densa.

# target_encoding.py
import pandas as pd
import numpy as np
from sklearn.model_selection import KFold

def target_encode_kfold(df, col, target, n_splits=5):
    """Target encoding with K-fold regularization to prevent leakage."""
    encoded = pd.Series(index=df.index, dtype=float)
    global_mean = df[target].mean()
    kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)

    for train_idx, val_idx in kf.split(df):
        # Compute means only from training fold
        means = df.iloc[train_idx].groupby(col)[target].mean()
        encoded.iloc[val_idx] = df.iloc[val_idx][col].map(means)

    # Fill categories unseen in training fold with global mean
    encoded.fillna(global_mean, inplace=True)
    return encoded

df = pd.DataFrame({
    'city': ['Paris', 'Lyon', 'Paris', 'Marseille', 'Lyon', 'Paris',
             'Marseille', 'Lyon', 'Paris', 'Marseille'],
    'hired': [1, 0, 1, 0, 1, 1, 0, 0, 1, 1]
})
df['city_encoded'] = target_encode_kfold(df, 'city', 'hired')
print(df[['city', 'city_encoded', 'hired']])

A abordagem K-fold previne vazamento de dados calculando as médias do alvo apenas em amostras fora do fold. Sem essa regularização, o target encoding sofre overfitting severo em datasets pequenos.

Conceitos Centrais de Machine Learning

P6: O que é o tradeoff viés-variância e como ele se manifesta em modelos baseados em árvores?

O viés mede o erro sistemático — o quanto as predições se afastam dos valores reais em média. A variância mede a sensibilidade ao conjunto de treinamento — o quanto as predições mudam entre diferentes amostras. Uma única árvore de decisão profunda tem baixo viés, mas alta variância: ela memoriza os dados de treinamento. Uma random forest reduz a variância por meio do bootstrap aggregating (bagging), mantendo baixo viés. As árvores com gradient boosting reduzem o viés iterativamente ajustando os resíduos, mas correm o risco de aumentar a variância sem regularização adequada (learning rate, profundidade máxima, subsampling).

P7: Por que a acurácia falha como métrica para datasets desbalanceados? Quais alternativas existem?

Em um dataset com 95% de amostras negativas e 5% positivas, um modelo que prevê "negativo" para toda entrada atinge 95% de acurácia sendo completamente inútil. Curvas de precisão-recall, F1 score e a área sob a curva de precisão-recall (AUPRC) capturam melhor o desempenho na classe minoritária. Para tarefas de ranking, o AUC-ROC funciona bem, pois avalia a capacidade de discriminação em todos os limiares.

# imbalanced_metrics.py
from sklearn.metrics import (
    classification_report, precision_recall_curve,
    average_precision_score, roc_auc_score
)
import numpy as np

# Simulated predictions on imbalanced data
np.random.seed(42)
y_true = np.array([0]*950 + [1]*50)  # 95/5 imbalance
y_scores = np.random.beta(2, 5, 1000)  # predicted probabilities
y_scores[y_true == 1] += 0.3  # positive class scores slightly higher
y_scores = np.clip(y_scores, 0, 1)
y_pred = (y_scores > 0.5).astype(int)

print(classification_report(y_true, y_pred, digits=3))
print(f"ROC AUC: {roc_auc_score(y_true, y_scores):.3f}")
print(f"Average Precision (AUPRC): {average_precision_score(y_true, y_scores):.3f}")

A pergunta de acompanhamento costuma ser: "Como você escolhe entre precisão e recall?" A resposta depende do custo de falsos positivos versus falsos negativos. A detecção de fraudes prioriza o recall (capturar fraude importa mais do que alarmes falsos). O filtro de spam prioriza a precisão (falsos positivos irritam mais os usuários do que spam não detectado).

P8: Explique a regularização L1 versus L2 e quando cada uma é preferida.

A regularização L1 (Lasso) adiciona a soma dos pesos absolutos à função de perda, forçando alguns coeficientes a zero exatamente. Isso produz modelos esparsos e atua como seleção embutida de features. A regularização L2 (Ridge) adiciona a soma dos pesos ao quadrado, reduzindo todos os coeficientes em direção a zero sem eliminar nenhum. Usa-se L1 quando muitas features são irrelevantes e a esparsidade é desejada. Usa-se L2 quando todas as features contribuem e a multicolinearidade está presente. Elastic Net combina ambas e é frequentemente a escolha padrão quando a proporção ideal é desconhecida.

P9: Como árvores com gradient boosting (XGBoost/LightGBM) tratam features categóricas de forma diferente?

O XGBoost tradicionalmente exige one-hot encoding ou ordinal encoding antes do treinamento. O LightGBM trata features categóricas nativamente por meio de um algoritmo de busca de splits otimizado que agrupa categorias por suas estatísticas de gradiente, reduzindo o espaço de busca exponencial para tempo linear. Esse tratamento nativo frequentemente supera o one-hot encoding, especialmente para features de alta cardinalidade, e explica por que o LightGBM geralmente treina mais rapidamente em datasets tabulares.

Avaliação e Validação de Modelos

P10: O que é vazamento de dados (data leakage) e quais são as três fontes mais comuns?

O vazamento de dados ocorre quando informações de fora da distribuição de treinamento infiltram o modelo, inflando as métricas de validação, mas degradando o desempenho em produção. As três fontes mais comuns:

1. Vazamento temporal: usar dados futuros para prever o passado (por exemplo, usar o lifetime value de um cliente para prever churn no primeiro mês)
2. Vazamento de alvo: features derivadas da variável alvo (por exemplo, "número de reembolsos" para prever "solicitará reembolso")
3. Vazamento de pré-processamento: ajustar scalers, encoders ou imputadores no dataset completo antes da divisão

# leakage_prevention.py
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score
import numpy as np

X = np.random.randn(1000, 10)
y = (X[:, 0] + X[:, 1] > 0).astype(int)

# WRONG: fit scaler on all data, then cross-validate
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # leakage: test fold info in scaling

# CORRECT: pipeline ensures preprocessing fits only on training folds
pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler()),
    ('model', GradientBoostingClassifier(n_estimators=100, random_state=42))
])
scores = cross_val_score(pipeline, X, y, cv=5, scoring='roc_auc')
print(f"AUC (no leakage): {scores.mean():.3f} +/- {scores.std():.3f}")

Os Pipelines do scikit-learn são a defesa padrão contra vazamento de pré-processamento. Cada etapa de transformação dentro do pipeline reajusta independentemente em cada fold de treinamento.

P11: Quando a validação cruzada de séries temporais deve substituir o K-fold padrão?

O K-fold padrão embaralha os dados aleatoriamente, o que quebra a ordem temporal. Para qualquer dataset em que as linhas tenham um componente temporal (preços de ações, atividade de usuários, dados de sensores), isso cria vazamento de futuro para passado. A validação cruzada de séries temporais usa janelas expansivas ou deslizantes: o conjunto de treinamento de cada fold contém apenas dados anteriores ao conjunto de validação. O scikit-learn fornece o TimeSeriesSplit para esse padrão.

Deep Learning e Redes Neurais

P12: Por que redes profundas usam ReLU em vez de sigmoid e quando o ReLU falha?

O sigmoid comprime as saídas para (0, 1), mas seu gradiente desaparece em entradas extremas — próximo a 0 ou 1, o gradiente se aproxima de zero, paralisando a retropropagação em redes profundas. O ReLU (max(0, x)) tem gradiente constante de 1 para entradas positivas, permitindo treinamento mais rápido. O ReLU falha quando neurônios recebem entradas consistentemente negativas (problema do "ReLU morto"), produzindo gradientes zero permanentemente. O Leaky ReLU e o GELU (usado em Transformers) abordam isso permitindo pequenos gradientes para valores negativos.

P13: Explique o mecanismo de atenção e por que os Transformers substituíram as RNNs para tarefas de sequência.

As RNNs processam sequências passo a passo, criando um gargalo: informações dos primeiros tokens precisam sobreviver por todos os estados ocultos subsequentes. A atenção calcula relações diretas par a par entre todas as posições simultaneamente, com complexidade O(n²), mas paralelização total. A self-attention em Transformers produz matrizes Query, Key e Value a partir da entrada, calculando pesos de atenção como softmax(QK^T / sqrt(d_k)) * V.

# self_attention.py
import torch
import torch.nn.functional as F

def self_attention(x, d_k):
    """Scaled dot-product self-attention from scratch."""
    # x shape: (batch_size, seq_len, d_model)
    batch_size, seq_len, d_model = x.shape

    # Linear projections for Q, K, V
    W_q = torch.randn(d_model, d_k) * 0.1
    W_k = torch.randn(d_model, d_k) * 0.1
    W_v = torch.randn(d_model, d_k) * 0.1

    Q = x @ W_q  # (batch, seq_len, d_k)
    K = x @ W_k
    V = x @ W_v

    # Scaled dot-product attention
    scores = Q @ K.transpose(-2, -1) / (d_k ** 0.5)  # (batch, seq_len, seq_len)
    weights = F.softmax(scores, dim=-1)  # attention weights
    output = weights @ V  # (batch, seq_len, d_k)

    return output, weights

# Example: 1 batch, 4 tokens, 8-dim embeddings
x = torch.randn(1, 4, 8)
out, attn = self_attention(x, d_k=8)
print(f"Output shape: {out.shape}")    # (1, 4, 8)
print(f"Attention weights:\n{attn[0].detach().numpy().round(3)}")

A principal vantagem: a atenção permite que o modelo conecte diretamente quaisquer duas posições independentemente da distância, resolvendo o problema de dependência de longo alcance que afetava as LSTMs.

P14: Qual é a diferença entre fine-tuning e transfer learning e quando cada um se aplica?

O transfer learning utiliza as representações aprendidas de um modelo pré-treinado como ponto de partida. O fine-tuning é uma estratégia específica de transfer learning que descongela algumas ou todas as camadas pré-treinadas e continua o treinamento na tarefa alvo. A extração de features (outra estratégia) congela todas as camadas pré-treinadas e treina apenas uma nova camada de classificação. O fine-tuning funciona melhor com dados moderados na tarefa alvo (milhares de amostras). A extração de features é adequada para datasets pequenos, onde o fine-tuning completo causaria overfitting.

SQL e Manipulação de Dados

P15: Escreva uma consulta para encontrar o segundo maior salário em cada departamento sem usar window functions.

-- second_highest_salary.sql
-- Approach: correlated subquery counting distinct higher salaries
SELECT d.department_name, e.employee_name, e.salary
FROM employees e
JOIN departments d ON e.department_id = d.id
WHERE (
    SELECT COUNT(DISTINCT e2.salary)
    FROM employees e2
    WHERE e2.department_id = e.department_id
      AND e2.salary > e.salary
) = 1
ORDER BY d.department_name;

Os entrevistadores usam essa questão para verificar os fundamentos de SQL sem a conveniência das funções RANK() ou DENSE_RANK(). A pergunta de acompanhamento é resolver com window functions, o que é mais limpo, mas testa uma habilidade diferente.

P16: Explique a diferença entre WHERE e HAVING. Quando cada um é avaliado?

WHERE filtra linhas antes da agregação. HAVING filtra grupos após a agregação. Na ordem de execução do SQL, WHERE se aplica durante a fase de varredura de linhas, GROUP BY cria os grupos, as funções de agregação calculam e então HAVING filtra esses grupos. Um erro comum: usar HAVING sem GROUP BY ou tentar referenciar aliases definidos em SELECT dentro do WHERE.

Data Science Aplicado e System Design

P17: Como você projetaria um teste A/B para um novo algoritmo de recomendação?

O design requer cinco componentes: (1) uma métrica primária clara (por exemplo, taxa de cliques, taxa de conversão ou receita por usuário), (2) uma análise de poder para determinar o tamanho da amostra, (3) randomização no nível de usuário (não de sessão, para evitar contaminação cruzada), (4) métricas de proteção que não podem degradar (latência, taxa de erros) e (5) um plano de análise pré-registrado para prevenir p-hacking.

P18: Um modelo tem bom desempenho na validação, mas fraco em produção. Quais são as três principais causas?

1. Mudança de distribuição (distribution shift): os dados de treinamento não representam o tráfego de produção (diferentes demografias de usuários, períodos de tempo ou geografias)
2. Skew de features: features calculadas de forma diferente no pipeline de treinamento (batch) versus serving (tempo real) — parsing de timestamps, tratamento de valores ausentes ou janelas de agregação divergem
3. Vazamento de label: o label de treinamento foi derivado de dados indisponíveis no momento da predição em produção

A depuração começa comparando as distribuições de features entre treinamento e produção usando testes estatísticos (teste KS, PSI — Population Stability Index) em cada feature independentemente.

P19: Explique o teorema CAP e suas implicações para feature stores de ML.

O CAP afirma que um sistema distribuído pode fornecer no máximo duas das três garantias: Consistência (toda leitura retorna a escrita mais recente), Disponibilidade (toda requisição recebe uma resposta) e Tolerância a partições (o sistema opera apesar de falhas de rede). As feature stores enfrentam diretamente esse tradeoff: os stores online (Redis, DynamoDB) priorizam disponibilidade e tolerância a partições, aceitando consistência eventual. Os stores offline (BigQuery, Hive) priorizam consistência para o treinamento em batch. Uma arquitetura de store duplo atende a ambas as necessidades.

P20: Como lidar com concept drift em um sistema de ML em produção?

O concept drift ocorre quando a relação estatística entre features e alvo muda ao longo do tempo. Os métodos de detecção incluem monitorar mudanças na distribuição de predições (PSI nas saídas do modelo), acompanhar métricas de desempenho em dados de produção rotulados e testes estatísticos nas distribuições de features recebidas. Estratégias de mitigação: retreinamento programado em uma janela deslizante, aprendizado online para drift gradual ou acionamento de retreinamento quando as métricas de drift ultrapassam limiares.

Python e Proficiência em Pandas

P21: Qual é a diferença entre apply(), map() e transform() no Pandas?

map() opera elemento a elemento apenas em uma Series. apply() funciona tanto em Series quanto em DataFrames, passando cada linha ou coluna para uma função. transform() exige que a saída tenha o mesmo formato que a entrada — não pode agregar. A implicação prática: transform() permite computações no nível de grupo que se propagam de volta ao índice original, o que apply() pode fazer, mas com menos eficiência.

# pandas_operations.py
import pandas as pd

df = pd.DataFrame({
    'team': ['A', 'A', 'B', 'B', 'A'],
    'score': [10, 20, 30, 40, 50]
})

# map: element-wise on Series
df['team_upper'] = df['team'].map({'A': 'Alpha', 'B': 'Beta'})

# apply: arbitrary function per row
df['score_label'] = df['score'].apply(lambda x: 'high' if x > 25 else 'low')

# transform: group-level, same shape output (broadcasts back)
df['team_mean'] = df.groupby('team')['score'].transform('mean')
df['score_normalized'] = df.groupby('team')['score'].transform(
    lambda x: (x - x.mean()) / x.std()
)
print(df)

P22: Explique o GIL do Python e seu impacto nos fluxos de trabalho de data science.

O Global Interpreter Lock impede que múltiplas threads executem bytecode Python simultaneamente. Tarefas ligadas à CPU (computação numérica, treinamento de modelos) não se beneficiam de threading. Por isso o NumPy, o pandas e o scikit-learn usam extensões em C que liberam o GIL, e o multiprocessing (não threading) é a estratégia de paralelismo padrão para código Python puro. Para tarefas ligadas a I/O (chamadas de API, consultas de banco de dados), o threading funciona porque o GIL é liberado durante as esperas de I/O.

Redução de Dimensionalidade e Aprendizado Não Supervisionado

P23: PCA versus t-SNE versus UMAP — quando cada um se aplica?

O PCA é um método linear que maximiza a variância nas dimensões projetadas. Preserva a estrutura global e é determinístico, tornando-o adequado para pré-processamento (reduzindo a contagem de features antes da modelagem) e visualização interpretável. O t-SNE é não linear, otimizado para visualização em 2D/3D preservando vizinhanças locais. Distorce as distâncias globais e não é adequado para pré-processamento. O UMAP preserva estrutura local e global melhor do que o t-SNE, executa mais rápido em grandes datasets e produz resultados mais consistentes entre execuções.

| Method | Linear | Preserves Global Structure | Speed (100K points) | Use Case | |--------|--------|---------------------------|---------------------|----------| | PCA | Yes | Yes | Seconds | Preprocessing, feature reduction | | t-SNE | No | No | Minutes | Cluster visualization (small data) | | UMAP | No | Partially | Seconds | Visualization + preprocessing |

P24: Como o K-means falha e quais alternativas lidam com clusters não esféricos?

O K-means assume clusters esféricos de tamanho igual e usa distância euclidiana. Ele falha em clusters alongados, em forma de anel ou com densidade variável. O DBSCAN identifica clusters por densidade, lidando com formas arbitrárias e detectando outliers automaticamente. Os Gaussian Mixture Models (GMMs) modelam cada cluster como uma gaussiana multivariada, permitindo formas elípticas. O clustering espectral usa os autovetores do Laplaciano do grafo e lida com geometrias complexas, mas escala mal para mais de aproximadamente 10 mil pontos.

Comunicação e Impacto no Negócio

P25: Um stakeholder pergunta: "Quais features são mais importantes no modelo?" Como você responde?

A importância de features tem múltiplas definições válidas, e a resposta depende do público. Para modelos baseados em árvores, existem três medidas comuns: importância baseada em splits (com que frequência uma feature é usada em divisões), importância baseada em ganho (redução total na perda das divisões naquela feature) e importância por permutação (quanto o desempenho cai quando uma feature é embaralhada aleatoriamente). Os valores SHAP fornecem a resposta mais rigorosa: quantificam a contribuição de cada feature para predições individuais usando princípios da teoria dos jogos.

# feature_importance_shap.py
import shap
import xgboost as xgb
from sklearn.datasets import make_classification

# Generate synthetic dataset
X, y = make_classification(n_samples=1000, n_features=10,
                           n_informative=5, random_state=42)

# Train XGBoost model
model = xgb.XGBClassifier(n_estimators=100, random_state=42, eval_metric='logloss')
model.fit(X, y)

# SHAP explanation
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X)

# Global importance: mean absolute SHAP value per feature
import numpy as np
importance = np.abs(shap_values).mean(axis=0)
for i in np.argsort(importance)[::-1]:
    print(f"Feature {i}: {importance[i]:.4f}")

Para stakeholders, traduza os valores SHAP para linguagem de negócio: "Clientes com renda acima de R$ 80 mil têm 15% mais probabilidade de converter, mantendo tudo o mais igual" em vez de "A Feature 3 tem valor SHAP médio de 0,23".

Conclusão

• A precisão nos testes de hipótese importa: saiba quando aplicar testes binomiais, entenda os p-valores e distinga o raciocínio bayesiano do frequentista
• O feature engineering frequentemente determina o desempenho do modelo mais do que a escolha do algoritmo — domine target encoding, estratégias para dados ausentes e prevenção de leakage
• A avaliação vai além da acurácia: use AUPRC para dados desbalanceados, TimeSeriesSplit para dados temporais e pipelines para prevenir vazamento de pré-processamento
• Os fundamentos de deep learning (atenção, funções de ativação, transfer learning) aparecem mesmo em funções de data science que utilizam principalmente métodos tabulares
• Perguntas sobre ML em produção (detecção de drift, testes A/B, feature stores) separam cada vez mais candidatos seniores de juniores
• Habilidades de comunicação são testadas por meio de explicações de importância de features — pratique a tradução de valores SHAP para linguagem acessível a stakeholders