Como aprender machine learning: um roteiro com fontes confiáveis

Quem decide aprender machine learning hoje enfrenta o problema oposto ao de dez anos atrás: não falta material, sobra. São milhares de cursos, vídeos e “roteiros definitivos”, muitos superficiais ou desatualizados. O resultado mais comum é passar meses consumindo tutoriais sem conseguir resolver um problema real.

Este artigo é o roteiro que eu seguiria, como desenvolvedor, montado apenas com fontes reconhecidas e, na maioria, gratuitas: o curso de Andrew Ng, o fast.ai, o Machine Learning Crash Course do Google, o material de Andrej Karpathy e as Rules of Machine Learning do Google.

Antes de começar: defina o objetivo

“Aprender ML” pode significar coisas bem diferentes:

Objetivo	O que você precisa	Profundidade em matemática
Usar modelos prontos (APIs de LLMs, modelos pré-treinados)	Engenharia de software, avaliação de resultados, noções de embeddings	Baixa
Treinar e colocar modelos em produção	ML clássico, deep learning, dados, MLOps	Média
Pesquisa	Tudo acima, mais matemática avançada e leitura de artigos	Alta

Este roteiro mira o segundo objetivo, que é onde a maioria dos desenvolvedores que querem “aprender ML de verdade” se encaixa. Para o primeiro, o artigo sobre como usar IA de forma produtiva é um ponto de partida melhor.

O que é machine learning, em uma frase

Em vez de escrever regras explícitas (“se o e-mail contém X, é spam”), você fornece exemplos e um algoritmo ajusta um modelo que generaliza a partir deles. Deep learning é o subconjunto que usa redes neurais com muitas camadas. LLMs são modelos de deep learning treinados em enormes volumes de texto.

Dois caminhos: de baixo para cima ou de cima para baixo

Existem duas filosofias de ensino, e as duas têm cursos excelentes:

• De baixo para cima (bottom-up): fundamentos primeiro, aplicação depois. É a linha da Machine Learning Specialization de Andrew Ng.
• De cima para baixo (top-down): usar um modelo funcionando desde a primeira aula e descer aos detalhes conforme a necessidade. É a proposta declarada do fast.ai, que ensina sempre por exemplos.

Minha recomendação é combinar: um curso de fundamentos para ter vocabulário e intuição, e um curso prático para ter resultado cedo e manter a motivação.

Etapa 0: Python e o ecossistema

Se você já programa em outra linguagem, o básico de Python vem rápido. O que importa conhecer:

• NumPy: operações com arrays e álgebra linear.
• pandas: manipulação de dados tabulares.
• Matplotlib (ou similar): visualização.
• Jupyter: notebooks para explorar dados.
• scikit-learn: a biblioteca de referência para ML clássico.

Etapa 1: a matemática que realmente importa

Você não precisa de uma graduação em matemática para começar, mas três áreas aparecem o tempo todo:

• Álgebra linear: vetores, matrizes, produto escalar, multiplicação de matrizes.
• Cálculo: derivadas, gradientes e regra da cadeia (a base do treinamento por gradiente).
• Probabilidade e estatística: distribuições, média, variância, probabilidade condicional, noções de inferência.

Duas fontes gratuitas que recomendo:

• Mathematics for Machine Learning, de Deisenroth, Faisal e Ong: livro completo, com PDF gratuito.
• A série sobre redes neurais do 3Blue1Brown: visualizações que dão intuição para gradiente e retropropagação.

Uma estratégia que funciona bem: aprender a matemática sob demanda, quando ela aparece no curso, em vez de tentar estudá-la toda antes.

Etapa 2: machine learning clássico

Aqui estão os conceitos que você vai usar para o resto da vida, mesmo com deep learning:

• aprendizado supervisionado (regressão e classificação) e não supervisionado (agrupamento);
• divisão entre treino, validação e teste;
• overfitting e underfitting, regularização;
• métricas: acurácia, precisão, recall, F1, AUC, erro médio;
• validação cruzada;
• engenharia de atributos.

Cursos recomendados:

• Machine Learning Specialization (DeepLearning.AI e Stanford Online, com Andrew Ng): três cursos, com laboratórios em Python usando NumPy e scikit-learn.
• Machine Learning Crash Course (Google): vídeos, visualizações interativas e exercícios, cobrindo de regressão a redes neurais, embeddings e uma introdução a LLMs.

Um primeiro experimento completo com scikit-learn, usando um dataset que já vem com a biblioteca:

from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

X, y = load_breast_cancer(return_X_y=True)

# Separa um conjunto de teste que só será usado no final.
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

# O pipeline garante que a normalização é aprendida só com os dados de treino.
model = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))

scores = cross_val_score(model, X_train, y_train, cv=5, scoring="f1")
print(f"F1 na validação cruzada: {scores.mean():.3f} ± {scores.std():.3f}")

model.fit(X_train, y_train)
print(classification_report(y_test, model.predict(X_test)))

Repare em dois detalhes que evitam erros clássicos: o conjunto de teste é separado antes de qualquer decisão, e o pré-processamento fica dentro do pipeline, para não vazar informação do teste para o treino (o chamado data leakage).

Etapa 3: deep learning

Com os fundamentos de ML clássico, deep learning fica muito mais claro.

• Practical Deep Learning for Coders (fast.ai): gratuito. Segundo o próprio site, o pré-requisito é saber programar (um ano de experiência basta, de preferência em Python) e ter feito matemática do ensino médio.
• Neural Networks: Zero to Hero (Andrej Karpathy): constrói redes neurais do zero, até um modelo de linguagem no estilo GPT. Excelente para entender o que acontece por baixo dos frameworks.
• Dive into Deep Learning: livro gratuito e interativo, com código.

O fast.ai e o Zero to Hero usam PyTorch, o que faz dele uma boa escolha de framework para começar.

Etapa 4: projetos com dados reais

Curso sem projeto não vira competência. Algumas fontes de prática:

• Kaggle: cursos curtos, datasets e competições com soluções publicadas por outros participantes.
• Dados do seu trabalho ou da sua cidade: um problema que você entende tem mais valor de aprendizado do que mais um classificador de flores.

Para conduzir um projeto, o texto A Recipe for Training Neural Networks (2019), de Karpathy, é leitura obrigatória. Ele lembra que o treinamento de redes neurais é uma abstração que vaza e que falha em silêncio: um modelo mal configurado costuma treinar mesmo assim, só que pior, sem erro nenhum. A receita começa por se tornar íntimo dos dados, montar o esqueleto completo de treino e avaliação com baselines simples, e só então partir para overfitting, regularização e ajuste fino.

Etapa 5: ML em produção

Colocar um modelo em produção é, na maior parte, um problema de engenharia. As Rules of Machine Learning, de Martin Zinkevich (Google), dizem isso já na introdução: a maioria dos problemas que você vai enfrentar são, na verdade, problemas de engenharia. As primeiras regras do documento são um ótimo filtro:

1. Não tenha medo de lançar um produto sem machine learning.
2. Primeiro, desenhe e implemente métricas.
3. Prefira machine learning a uma heurística complexa.
4. Mantenha o primeiro modelo simples e acerte a infraestrutura.

Na prática, isso significa versionar dados e modelos, monitorar a qualidade das previsões ao longo do tempo (os dados mudam, e o modelo envelhece), ter um caminho de rollback e comparar sempre com uma baseline simples.

Erros comuns

• Tutorial infinito: consumir cursos sem nunca resolver um problema próprio.
• Pular a análise de dados: ir direto para o modelo sem olhar distribuições, valores ausentes e erros nos rótulos.
• Data leakage: usar, sem perceber, informação do conjunto de teste no treino.
• Acurácia em dados desbalanceados: um classificador que sempre responde “não é fraude” pode ter 99% de acurácia e ser inútil.
• Correr atrás do estado da arte: uma regressão logística bem avaliada resolve mais problemas reais do que parece.
• Esquecer a baseline: sem comparar com algo simples, não dá para saber se o modelo agrega valor.

Um plano sugerido

Uma sugestão de sequência, com ritmo de algumas horas por semana. Os prazos são indicativos e dependem muito da sua base:

Fase	Foco	Material principal
1	Python, NumPy e pandas	Documentação oficial e Kaggle Learn
2	ML clássico	Machine Learning Specialization ou ML Crash Course
3	Primeiro projeto completo	Um dataset real, com baseline e avaliação honesta
4	Deep learning	fast.ai e Zero to Hero
5	Segundo projeto, agora com deep learning	Receita de Karpathy
6	Produção	Rules of ML, deploy de um modelo simples com monitoramento

Referências

Este artigo é um estudo baseado nas fontes abaixo. Trechos marcados como opinião refletem a minha leitura.

• DeepLearning.AI e Stanford Online. Machine Learning Specialization.
• Google. Machine Learning Crash Course.
• fast.ai. Practical Deep Learning for Coders.
• Andrej Karpathy. Neural Networks: Zero to Hero.
• Andrej Karpathy. A Recipe for Training Neural Networks (abril de 2019).
• Martin Zinkevich, Google. Rules of Machine Learning: Best Practices for ML Engineering.
• Marc Peter Deisenroth, A. Aldo Faisal e Cheng Soon Ong. Mathematics for Machine Learning. Cambridge University Press, 2020.
• Aston Zhang et al. Dive into Deep Learning.
• scikit-learn. User Guide.