# Algoritmos de Machine Learning Explicados: Guia Completo para Entrevistas Tecnicas

> Guia completo de algoritmos de machine learning para entrevistas tecnicas. Cobre modelos lineares, arvores de decisao, metodos ensemble, clustering, metricas de avaliacao e regularizacao com scikit-learn.

- Published: 2026-04-06
- Updated: 2026-04-06
- Author: Anthony Fillion-Maillet
- Tags: machine-learning, data-science, interview-preparation, python, scikit-learn
- Reading time: 10 min

---

Algoritmos de machine learning constituem o pilar central de qualquer entrevista tecnica em data science em 2026. Independentemente do nivel da vaga — cientista de dados junior ou engenheiro de ML senior — os entrevistadores esperam que candidatos saibam explicar, implementar e comparar as principais familias de algoritmos, de modelos lineares a metodos ensemble e tecnicas nao supervisionadas. Este guia aborda cada categoria relevante com implementacoes praticas em Python usando [scikit-learn 1.8](https://scikit-learn.org/stable/index.html), estrategias de avaliacao e os tradeoffs exatos que separam candidatos fortes dos demais.

> **Familias de Algoritmos em Resumo**
>
> Os algoritmos de machine learning se dividem em tres grandes familias: aprendizado supervisionado (regressao e classificacao), aprendizado nao supervisionado (clustering e reducao de dimensionalidade) e aprendizado por reforco. Entrevistas tecnicas em 2026 concentram-se nas duas primeiras, com enfase em quando escolher um algoritmo em vez de outro e como avaliar os resultados corretamente.

## Aprendizado Supervisionado: Fundamentos de Regressao e Classificacao

Algoritmos de aprendizado supervisionado aprendem a partir de dados rotulados — cada exemplo de treinamento possui uma entrada e a saida esperada. Regressao preve valores continuos (precos de imoveis, temperaturas), enquanto classificacao atribui rotulos discretos (spam/nao-spam, diagnostico de doencas). Dominar ambos e pre-requisito em [entrevistas de data science](/blog/data-science/top-25-data-science-interview-questions-2026).

A regressao linear permanece como ponto de partida para qualquer tarefa de regressao. O modelo descreve a relacao entre features e uma variavel-alvo como uma soma ponderada. Entrevistadores costumam pedir que candidatos implementem o algoritmo, expliquem a funcao de custo e discutam situacoes em que o modelo falha.

```python
# linear_regression_demo.py
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# Generate synthetic housing data: square footage -> price
np.random.seed(42)
sqft = np.random.uniform(500, 3000, size=200).reshape(-1, 1)
price = 150 * sqft.flatten() + np.random.normal(0, 20000, size=200)

X_train, X_test, y_train, y_test = train_test_split(sqft, price, test_size=0.2)

model = LinearRegression()
model.fit(X_train, y_train)                    # Fit on training data
predictions = model.predict(X_test)            # Predict on unseen data

print(f"Coefficient: {model.coef_[0]:.2f}")    # Weight per sqft
print(f"R2 Score: {r2_score(y_test, predictions):.4f}")
print(f"RMSE: {np.sqrt(mean_squared_error(y_test, predictions)):.2f}")
```

O coeficiente revela quanto cada metro quadrado adicional contribui para o preco. O R2 score e o RMSE quantificam a qualidade das previsoes — duas metricas que entrevistadores esperam que candidatos interpretem sem hesitacao.

Na classificacao, a regressao logistica aplica uma funcao sigmoide para produzir probabilidades. Apesar do nome, resolve problemas de classificacao. A fronteira de decisao, o parametro de regularizacao C e a diferenca entre cenarios binarios e multiclasse sao topicos recorrentes em entrevistas.

```python
# logistic_classification.py
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

data = load_breast_cancer()                    # Binary classification dataset
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2, random_state=42
)

clf = LogisticRegression(max_iter=5000, C=1.0) # C controls regularization strength
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

print(classification_report(y_test, y_pred, target_names=data.target_names))
```

O classification report exibe precision, recall e F1-score por classe — exatamente as metricas abordadas na proxima secao. Saber ler esse relatorio com fluencia e diferencial; entrevistadores percebem rapidamente quando candidatos tem dificuldade na interpretacao.

## Arvores de Decisao e Metodos Ensemble nas Entrevistas

Arvores de decisao dividem dados recursivamente com base em thresholds de features. Isoladamente, tendem a sofrer overfitting. Metodos ensemble — Random Forest e Gradient Boosting — resolvem esse problema combinando multiplas arvores. Esses algoritmos aparecem em praticamente toda entrevista de ML porque equilibram interpretabilidade e performance.

O Random Forest constroi varias arvores independentes sobre amostras bootstrap e faz a media das previsoes, reduzindo a variancia sem aumentar o vies. [Perguntas de entrevista sobre arvores e ensembles](/technologies/data-science/interview-questions/ml-trees-ensembles) frequentemente testam a compreensao de bagging vs. boosting, importancia de features e estimativa de erro out-of-bag.

```python
# ensemble_comparison.py
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.datasets import load_wine
from sklearn.model_selection import cross_val_score

data = load_wine()                             # 3-class classification
X, y = data.data, data.target

# Random Forest: parallel trees, reduces variance
rf = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)
rf_scores = cross_val_score(rf, X, y, cv=5, scoring='accuracy')

# Gradient Boosting: sequential trees, reduces bias
gb = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3)
gb_scores = cross_val_score(gb, X, y, cv=5, scoring='accuracy')

print(f"Random Forest:     {rf_scores.mean():.4f} +/- {rf_scores.std():.4f}")
print(f"Gradient Boosting: {gb_scores.mean():.4f} +/- {gb_scores.std():.4f}")
```

O Random Forest se destaca quando o objetivo e estabilidade com pouco esforco de tuning. O Gradient Boosting frequentemente atinge acuracia superior, porem exige selecao cuidadosa de hiperparametros — learning rate, numero de estimadores e profundidade das arvores interagem entre si. Entrevistadores avaliam se candidatos entendem esse tradeoff, nao apenas qual numero e maior.

| Criterion | Random Forest | Gradient Boosting |
|-----------|--------------|-------------------|
| Training speed | Fast (parallel) | Slower (sequential) |
| Overfitting risk | Low | Higher without tuning |
| Hyperparameter sensitivity | Low | High |
| Feature importance | Built-in (impurity-based) | Built-in (gain-based) |
| Best for | Baseline models, noisy data | Competitions, tabular data |

## Aprendizado Nao Supervisionado: Clustering e Reducao de Dimensionalidade

Algoritmos nao supervisionados encontram estrutura em dados sem rotulos. K-Means (clustering) e PCA (Analise de Componentes Principais) sao as duas tecnicas mais cobradas em entrevistas. Dominar ambas e essencial para se preparar para [perguntas sobre aprendizado nao supervisionado](/technologies/data-science/interview-questions/ml-unsupervised).

O K-Means particiona dados em k clusters minimizando a variancia intra-cluster. O algoritmo itera entre atribuir pontos ao centroide mais proximo e atualizar centroides. Duas perguntas classicas de entrevista: como escolher k (metodo do cotovelo, silhouette score) e o que acontece com clusters nao esfericos.

```python
# kmeans_clustering.py
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score
from sklearn.datasets import load_iris

data = load_iris()
X = StandardScaler().fit_transform(data.data)  # Scale features first

# Test multiple values of k to find optimal cluster count
for k in [2, 3, 4, 5]:
    kmeans = KMeans(n_clusters=k, n_init=10, random_state=42)
    labels = kmeans.fit_predict(X)
    sil = silhouette_score(X, labels)          # Higher = better-defined clusters
    inertia = kmeans.inertia_                  # Within-cluster sum of squares
    print(f"k={k}: silhouette={sil:.3f}, inertia={inertia:.1f}")
```

Escalar as features antes do clustering e obrigatorio — o K-Means usa distancia euclidiana, entao features nao padronizadas com intervalos grandes dominam a metrica. Esse detalhe aparece em entrevistas com frequencia.

O PCA reduz a dimensionalidade projetando os dados nas direcoes de maxima variancia. Serve a dois propositos: visualizacao (projecao para 2D/3D) e pre-processamento (remocao de ruido, aceleracao de modelos subsequentes). Entrevistadores esperam que candidatos expliquem as razoes de variancia explicada e como escolher o numero de componentes.

> **Quando o PCA Ajuda — e Quando Atrapalha**
>
> O PCA funciona melhor quando as features sao correlacionadas e o sinal se concentra em poucas direcoes. Em dados esparsos e de alta dimensionalidade (texto, variaveis one-hot encoded), o PCA pode destruir estrutura util. Nessas situacoes, Truncated SVD ou embeddings especializados apresentam resultados superiores.

## Metricas de Avaliacao que Todo Candidato Precisa Dominar

Escolher a metrica de avaliacao correta importa mais do que escolher o algoritmo certo. Um modelo com 99% de acuracia em dados desbalanceados (1% de fraude) pode ser inutil — basta prever "nao fraude" para todos os exemplos. Entrevistadores usam perguntas sobre metricas para testar o julgamento pratico dos candidatos.

Na classificacao, quatro metricas dominam as entrevistas:

- **Precision**: de todas as previsoes positivas, quantas estao corretas? Fundamental quando falsos positivos sao custosos (filtragem de spam)
- **Recall**: de todos os positivos reais, quantos foram encontrados? Fundamental quando falsos negativos sao custosos (triagem de doencas)
- **F1-Score**: media harmonica de precision e recall — a escolha equilibrada quando nenhum tipo de erro domina claramente
- **AUC-ROC**: mede a qualidade do ranking entre todos os thresholds de classificacao — essencial para comparar modelos

Na regressao, as metricas-chave sao RMSE (penaliza erros grandes), MAE (robusto a outliers) e R2 (proporcao da variancia explicada). Saber quando preferir MAE em vez de RMSE — ou vice-versa — sinaliza compreensao genuina do problema. A pratica com essas metricas pode ser aprofundada em [cenarios de entrevista sobre regressao](/technologies/data-science/interview-questions/ml-supervised-regression).

```python
# evaluation_metrics.py
from sklearn.metrics import (
    precision_score, recall_score, f1_score,
    roc_auc_score, confusion_matrix
)
import numpy as np

# Simulated predictions on imbalanced data (5% positive class)
np.random.seed(42)
y_true = np.array([1]*50 + [0]*950)
y_pred = np.array([1]*40 + [0]*10 + [1]*30 + [0]*920)  # Some errors

print(f"Precision: {precision_score(y_true, y_pred):.3f}")  # 40/(40+30) = 0.571
print(f"Recall:    {recall_score(y_true, y_pred):.3f}")     # 40/(40+10) = 0.800
print(f"F1-Score:  {f1_score(y_true, y_pred):.3f}")         # Harmonic mean

cm = confusion_matrix(y_true, y_pred)
print(f"\nConfusion Matrix:\n{cm}")
# [[920, 30],   -> TN=920, FP=30
#  [10,  40]]   -> FN=10,  TP=40
```

Interpretar corretamente uma matriz de confusao exige pratica. A celula superior-esquerda (verdadeiros negativos) e a inferior-direita (verdadeiros positivos) representam previsoes corretas. As celulas fora da diagonal mostram os dois tipos de erro. Entrevistadores frequentemente apresentam uma matriz de confusao e pedem que candidatos calculem precision e recall a partir dela.

## Tradeoff Vies-Variancia e Estrategias de Regularizacao

O tradeoff vies-variancia (bias-variance tradeoff) e o conceito isolado mais importante em teoria de machine learning. Alto vies significa que o modelo e simples demais e sofre underfitting. Alta variancia significa que o modelo e complexo demais e sofre overfitting. Cada escolha de algoritmo e decisao de hiperparametro envolve navegar esse tradeoff.

A regularizacao controla a complexidade do modelo penalizando coeficientes grandes. A regressao Ridge (L2) encolhe os coeficientes em direcao a zero, mas mantem todas as features. A regressao Lasso (L1) leva alguns coeficientes exatamente a zero, realizando selecao implicita de features. O Elastic Net combina ambas as abordagens. Essas distincoes aparecem tanto em [perguntas de entrevista sobre classificacao](/technologies/data-science/interview-questions/ml-supervised-classification) quanto em contextos de regressao.

> **Armadilha Classica: Regularizacao sem Padronizacao**
>
> A regularizacao penaliza a magnitude dos coeficientes. Se as features possuem escalas diferentes (idade em anos vs. renda em milhares), a penalidade afeta desproporcionalmente as features de menor escala. Padronizar as features antes de aplicar Ridge, Lasso ou Elastic Net e obrigatorio. Esquecer esse passo e um erro frequente em entrevistas.

```python
# regularization_comparison.py
from sklearn.linear_model import Ridge, Lasso, ElasticNet
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_diabetes

X, y = load_diabetes(return_X_y=True)

models = {
    "Ridge (L2)":      make_pipeline(StandardScaler(), Ridge(alpha=1.0)),
    "Lasso (L1)":      make_pipeline(StandardScaler(), Lasso(alpha=0.1)),
    "ElasticNet (L1+L2)": make_pipeline(StandardScaler(), ElasticNet(alpha=0.1, l1_ratio=0.5)),
}

for name, model in models.items():
    scores = cross_val_score(model, X, y, cv=5, scoring='r2')
    print(f"{name:25s}  R2: {scores.mean():.4f} +/- {scores.std():.4f}")
```

O pipeline garante que padronizacao e regularizacao acontecam juntas, prevenindo data leakage ao ajustar o scaler nos dados de teste. Entrevistadores testam especificamente esse ponto: aplicar `fit_transform` no dataset completo antes do split e um erro eliminatorio em entrevistas de nivel senior.

## Como se Preparar para Perguntas sobre Algoritmos de ML em 2026

A preparacao para entrevistas sobre algoritmos de machine learning em 2026 vai alem de decorar formulas. Equipes de contratacao avaliam tres dimensoes: compreensao teorica (o candidato consegue explicar a matematica?), implementacao pratica (consegue escrever o codigo?) e julgamento (sabe qual algoritmo se encaixa no problema?).

A [trilha de preparacao para entrevistas de data science](/technologies/data-science) no SharpSkill cobre as tres dimensoes com questoes praticas. As areas que geram mais perguntas em entrevistas incluem:

- **Selecao de algoritmos**: dado a descricao de um dataset, justificar a escolha de um algoritmo em detrimento de outro. Considerar tamanho dos dados, tipos de features, requisitos de interpretabilidade e restricoes de tempo de treinamento
- **Tuning de hiperparametros**: explicar o que cada hiperparametro controla e como afeta o tradeoff vies-variancia. Grid search e random search sao o basico — otimizacao bayesiana com [Optuna](https://optuna.readthedocs.io/en/stable/) e cada vez mais esperada
- **Preocupacoes de producao**: deteccao de data drift, monitoramento de modelos, testes A/B e feature stores sao topicos padrao para vagas de nivel pleno e senior em 2026
- **Explicabilidade**: com a ascensao da IA explicavel, candidatos devem conhecer SHAP values e metodos de importancia de features. A [documentacao do scikit-learn](https://scikit-learn.org/stable/index.html) oferece implementacoes de referencia solidas

A validacao cruzada merece atencao especial. Entrevistadores esperam que candidatos expliquem por que splits de holdout simples sao insuficientes, como o k-fold cross-validation funciona e quando folds estratificados sao necessarios (classes desbalanceadas). Dados de series temporais exigem split temporal — um detalhe que pega muitos candidatos desprevenidos.

## Conclusao

- Modelos lineares (regressao linear e logistica) sao a base — compreender suas premissas, funcoes de custo e limitacoes antes de avancar para algoritmos complexos
- Arvores de decisao sofrem overfitting isoladamente; Random Forest e Gradient Boosting corrigem isso por meio de bagging e boosting respectivamente, com perfis de tradeoff distintos
- K-Means e PCA cobrem os fundamentos do aprendizado nao supervisionado, mas padronizar features primeiro e conhecer as limitacoes de cada metodo e indispensavel
- Metricas de avaliacao devem corresponder ao problema de negocio — acuracia sozinha e irrelevante em dados desbalanceados; precision, recall, F1 e AUC-ROC servem a objetivos diferentes
- Regularizacao (Ridge, Lasso, Elastic Net) controla o overfitting, mas so funciona corretamente em features padronizadas dentro de um pipeline
- Sucesso em entrevistas de 2026 exige demonstrar julgamento na selecao de algoritmos, nao apenas habilidade de implementacao — explicar o "por que" por tras de cada escolha e o diferencial

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/pt/blog/data-science/machine-learning-algorithms-explained