Phase 02 - Lesson 01

O que é aprendizado de máquina

This lesson includes a graded coding exercise that runs in your browser, unlocked with lifetime access.

O aprendizado de máquina está ensinando os computadores a encontrar padrões nos dados, em vez de escrever regras manualmente.

Tipo: Aprender Idiomas: Python Pré-requisitos: Fase 1 (Fundamentos Matemáticos) Tempo: ~45 minutos

Objetivos de aprendizagem

• Explicar a diferença entre aprendizagem supervisionada, não supervisionada e por reforço e identificar qual tipo se aplica a um determinado problema
• Implementar um classificador centróide mais próximo do zero e avaliá-lo em relação a uma linha de base aleatória
• Distinguir entre tarefas de classificação e regressão e selecionar a função de perda apropriada para cada uma
• Avaliar se um determinado problema de negócio é adequado para ML ou melhor resolvido com regras determinísticas

O problema

Você deseja construir um filtro de spam. A abordagem tradicional: sentar e escrever centenas de regras. "Se o e-mail contiver 'DINHEIRO GRÁTIS', marque-o como spam. Se tiver mais de 3 pontos de exclamação, marque-o como spam." Você passa semanas escrevendo regras. Então os spammers mudam seu texto. Suas regras quebram. Você escreve mais regras. O ciclo nunca termina.

O aprendizado de máquina inverte isso. Em vez de escrever regras, você dá ao computador milhares de e-mails rotulados (“spam” ou “não spam”) e deixa que ele descubra as regras sozinho. O computador encontra padrões nos quais você nunca teria pensado. Quando os spammers mudam de tática, você treina novamente com novos dados em vez de reescrever o código.

Essa mudança de “regras de programação” para “aprender com dados” é o núcleo do aprendizado de máquina. Cada mecanismo de recomendação, assistente de voz, carro autônomo e modelo de linguagem funcionam dessa maneira.

O Conceito

Aprendendo com dados, não com regras

A programação tradicional e o aprendizado de máquina resolvem problemas em direções opostas.

flowchart LR
    subgraph Traditional["Traditional Programming"]
        direction LR
        R[Rules] --> P1[Program]
        D1[Data] --> P1
        P1 --> O1[Output]
    end

    subgraph ML["Machine Learning"]
        direction LR
        D2[Data] --> P2[Learning Algorithm]
        O2[Expected Output] --> P2
        P2 --> M[Model / Rules]
    end

Programação tradicional: você escreve as regras. O programa os aplica aos dados para produzir resultados.

Aprendizado de máquina: você fornece dados e resultados esperados. O algoritmo descobre as regras.

O “modelo” que sai do treinamento SÃO as regras, codificadas como números (pesos, parâmetros). Generaliza a partir de exemplos que viu para fazer previsões sobre dados que nunca viu.

Os três tipos de aprendizado de máquina

flowchart TD
    ML[Machine Learning] --> SL[Supervised Learning]
    ML --> UL[Unsupervised Learning]
    ML --> RL[Reinforcement Learning]

    SL --> C[Classification]
    SL --> R[Regression]

    UL --> CL[Clustering]
    UL --> DR[Dimensionality Reduction]

    RL --> PO[Policy Optimization]
    RL --> VL[Value Learning]

Aprendizado supervisionado: você tem pares de entrada-saída. O modelo aprende a mapear entradas em saídas.

• "Aqui estão 10.000 fotos rotuladas como gato ou cachorro. Aprenda a diferenciá-las."
• "Aqui estão as características e os preços da casa. Aprenda a prever o preço."

Aprendizagem não supervisionada: você tem apenas entradas. Sem rótulos. O modelo encontra estrutura por conta própria.

• "Aqui estão 10.000 históricos de compras de clientes. Encontre agrupamentos naturais."
• "Aqui estão 1.000 pontos de dados dimensionais. Reduza para 2 dimensões enquanto mantém a estrutura."

Aprendizado por Reforço: um agente realiza ações em um ambiente e recebe recompensas ou penalidades. Aprende uma estratégia (política) para maximizar a recompensa total.

• "Jogue este jogo. +1 para ganhar, -1 para perder. Descubra uma estratégia."
• "Controle este braço robótico. +1 para pegar o objeto, -0,01 para cada segundo desperdiçado."

A maior parte do que você construirá na prática utiliza aprendizado supervisionado. O aprendizado não supervisionado é comum para pré-processamento e exploração. O aprendizado por reforço potencializa IA de jogos, robótica e RLHF para modelos de linguagem.

Além dos Três Grandes

As três categorias acima são claras, mas o ML do mundo real muitas vezes confunde os limites.

Aprendizagem semissupervisionada usa um pequeno conjunto de dados rotulados e um grande conjunto de dados não rotulados. Você pode ter 100 imagens médicas rotuladas e 100.000 não rotuladas. As técnicas incluem:

• Propagação de rótulo: Construa um gráfico conectando pontos de dados semelhantes. Os rótulos se espalham dos nós rotulados para os vizinhos não rotulados através do gráfico.
• Pseudo-rotulagem: treine um modelo nos dados rotulados, use-o para prever rótulos para dados não rotulados e, em seguida, treine novamente em tudo. O modelo inicializa seu próprio conjunto de treinamento.
• Regularização de consistência: O modelo deve fornecer a mesma previsão para uma entrada e uma versão ligeiramente perturbada dessa entrada. Isso funciona mesmo sem rótulos.

Aprendizado autossupervisionado cria supervisão a partir dos próprios dados. Não são necessários rótulos humanos. O modelo cria sua própria tarefa de previsão a partir da estrutura dos dados.

• Modelagem de linguagem mascarada (BERT): Oculte 15% das palavras em uma frase, treine o modelo para prever as palavras que faltam. Os "rótulos" vêm do texto original.
• Aprendizado contrastivo (SimCLR): Pegue uma imagem e crie duas versões aumentadas. Treine o modelo para reconhecer que eles vieram da mesma imagem e, ao mesmo tempo, distingui-los de versões aumentadas de outras imagens.
• Previsão do próximo token (GPT): Preveja a próxima palavra com base em todas as palavras anteriores. Cada documento de texto se torna um exemplo de treinamento.

Estas não são categorias separadas das três grandes. São estratégias que combinam ideias supervisionadas e não supervisionadas. A aprendizagem autossupervisionada é tecnicamente supervisionada (o modelo prevê algo), mas os rótulos são gerados automaticamente, não por humanos.

Classificação vs Regressão

Estas são as duas principais tarefas de aprendizagem supervisionada.

A classificação responde "qual categoria?" A regressão responde "quanto?"

Alguns problemas podem ser enquadrados de qualquer maneira. Prever se uma ação sobe ou desce é classificação. Prever o preço exato é uma regressão.

O fluxo de trabalho de ML

Todo projeto de aprendizado de máquina segue o mesmo pipeline, independentemente do algoritmo.

flowchart LR
    A[Collect Data] --> B[Clean & Explore]
    B --> C[Feature Engineering]
    C --> D[Split Data]
    D --> E[Train Model]
    E --> F[Evaluate]
    F -->|Not good enough| C
    F -->|Good enough| G[Deploy]
    G --> H[Monitor]
    H -->|Performance drops| A

Coletar dados: Reúna dados brutos. Mais dados são quase sempre melhores, mas a qualidade é mais importante do que a quantidade.

Limpar e explorar: lide com valores ausentes, remova duplicatas, visualize distribuições e detecte anomalias. Essa etapa geralmente leva de 60 a 80% do tempo total do projeto.

Engenharia de características: transforme dados brutos em características que o modelo pode usar. Transforme as datas em dias da semana. Normalize colunas numéricas. Codifique variáveis ​​categóricas. Boas características são mais importantes do que algoritmos sofisticados.

Dados divididos: divida em conjuntos de treinamento, validação e teste. O modelo treina em dados de treinamento, você ajusta hiperparâmetros em dados de validação e relata o desempenho final em dados de teste.

Treinar modelo: insira dados de treinamento em um algoritmo. O algoritmo ajusta parâmetros internos para minimizar uma função de perda.

Avaliar: Meça o desempenho em dados de validação/teste. Se o desempenho não for aceitável, volte e experimente diferentes características, algoritmos ou hiperparâmetros.

Implantar: coloque o modelo em produção para fazer previsões sobre novos dados.

Monitorar: acompanhe o desempenho ao longo do tempo. As distribuições de dados mudam (desvio de dados) e os modelos são degradados. Quando o desempenho cair, treine novamente.

Treinamento, validação e divisões de teste

Este é o conceito mais importante que os iniciantes erram. Você deve avaliar seu modelo com base em dados que ele nunca viu durante o treinamento. Caso contrário, você estará medindo a memorização e não o aprendizado.

flowchart LR
    subgraph Dataset["Full Dataset (100%)"]
        direction LR
        TR["Training Set (70%)"]
        VA["Validation Set (15%)"]
        TE["Test Set (15%)"]
    end

    TR -->|Train model| M[Model]
    M -->|Tune hyperparameters| VA
    VA -->|Final evaluation| TE

O conjunto de testes é sagrado. Você olha exatamente uma vez. Se você continuar ajustando seu modelo com base no desempenho do teste, estará efetivamente treinando no conjunto de testes e os números relatados não terão sentido.

Para conjuntos de dados pequenos, use validação cruzada k-fold: divida os dados em k partes, treine em k-1 partes, valide na parte restante, gire e calcule a média dos resultados.

Overfitting vs Underfitting

flowchart LR
    subgraph UF["Underfitting"]
        U1["Model too simple"]
        U2["High bias"]
        U3["Misses patterns"]
    end

    subgraph GF["Good Fit"]
        G1["Right complexity"]
        G2["Balanced"]
        G3["Generalizes well"]
    end

    subgraph OF["Overfitting"]
        O1["Model too complex"]
        O2["High variance"]
        O3["Memorizes noise"]
    end

    UF -->|Increase complexity| GF
    GF -->|Too much complexity| OF

Underfitting: o modelo é muito simples para capturar os padrões nos dados. Uma linha reta tentando encaixar uma relação curva. O erro de treinamento é alto. O erro do teste é alto.

Overfitting: o modelo é muito complexo e memoriza os dados de treinamento, incluindo seu ruído. Uma curva sinuosa que passa por todos os pontos de treinamento, mas falha em novos dados. O erro de treinamento é baixo. O erro do teste é alto.

Bom ajuste: O modelo captura padrões reais sem memorizar ruídos. O erro de treinamento e o erro de teste são razoavelmente baixos.

Sinais de overfitting:

• A precisão do treinamento é muito maior que a precisão da validação
• O modelo tem um bom desempenho em dados de treinamento, mas fraco em novos dados
• Adicionar mais dados de treinamento melhora o desempenho (o modelo estava memorizando, não aprendendo)

Correções para overfitting:

• Obtenha mais dados de treinamento
• Reduza a complexidade do modelo (menos parâmetros, arquitetura mais simples)
• Regularização (adicionar penalidade para pesos grandes)
• Dropout (zerar neurônios aleatoriamente durante o treinamento)
• Parada antecipada (parar o treinamento quando o erro de validação começar a aumentar)

Correções para underfitting:

• Use um modelo mais complexo
• Adicione mais recursos
• Reduzir a regularização
• Treine mais

A compensação entre polarização e variância

Esta é a estrutura matemática por trás do overfitting e do underfitting.

Viés: Erro devido a suposições erradas no modelo. Um modelo linear tem alto viés quando o relacionamento verdadeiro é não linear. O alto viés leva ao underfitting.

Variância: Erro de sensibilidade a pequenas flutuações nos dados de treinamento. Um modelo com alta variância fornece previsões muito diferentes quando treinado em diferentes subconjuntos de dados. Alta variância leva ao overfitting.

Erro total = Polarização ^ 2 + Variância + Ruído irredutível

Você não pode reduzir o ruído irredutível (é aleatoriedade nos próprios dados). Você deseja encontrar o ponto ideal onde o viés ^ 2 + a variância é minimizado.

Teorema sem almoço grátis

Não existe um algoritmo único que funcione melhor para todos os problemas. Um algoritmo que funciona bem em uma classe de problemas terá um desempenho ruim em outra. É por isso que os cientistas de dados tentam vários algoritmos e comparam os resultados.

Na prática, a escolha depende de:

• Quantos dados você tem
• Quantos recursos existem
• Se a relação é linear ou não linear
• Se você precisa de interpretabilidade
• Quanto cálculo você pode pagar

Quando NÃO usar aprendizado de máquina

O ML é poderoso, mas nem sempre é a ferramenta certa. Antes de pegar um modelo, pergunte se você realmente precisa de um.

Não use ML quando:

• As regras são simples e bem definidas. Cálculo de impostos, algoritmos de classificação, conversões de unidades. Se você puder escrever a lógica em algumas instruções if, um modelo adicionará complexidade sem nenhum benefício.
• Você não tem dados ou tem poucos dados. O ML precisa de exemplos para aprender. Com 10 pontos de dados, você não pode treinar nada significativo. Colete os dados primeiro.
• O custo de estar errado é catastrófico e você precisa de correção garantida. Cálculo de dosagem médica, controle de reator nuclear, verificação criptográfica. Os modelos de ML são probabilísticos. Às vezes eles estarão errados. Se “às vezes errado” for inaceitável, use métodos determinísticos.
• Uma tabela de pesquisa ou heurística resolve o problema. Se um limite ou tabela simples cobrir 99% dos casos, adicionar ML aumenta o custo de manutenção sem melhorias significativas.
• Você não pode explicar a decisão e é necessária explicabilidade. Os setores regulamentados (empréstimos, seguros, justiça criminal) às vezes exigem que cada decisão seja totalmente explicável. Alguns modelos de ML são interpretáveis ​​(regressão linear, pequenas árvores de decisão). A maioria não é.
• O problema muda mais rápido do que você consegue retreinar. Se as regras mudam diariamente e o retreinamento leva uma semana, o modelo fica sempre obsoleto.

Use este fluxograma de decisão:

flowchart TD
    A["Do you have data?"] -->|No| B["Collect data first or use rules"]
    A -->|Yes| C["Can you write the rules explicitly?"]
    C -->|"Yes, and they are simple"| D["Use rules. Skip ML."]
    C -->|"No, or they are too complex"| E["Is the cost of errors acceptable?"]
    E -->|"No, need guaranteed correctness"| F["Use deterministic methods"]
    E -->|Yes| G["Do you need explainability?"]
    G -->|"Yes, strictly"| H["Use interpretable models only"]
    G -->|"No, or partially"| I["Use ML"]
    I --> J["Do you have enough labeled data?"]
    J -->|Yes| K["Supervised learning"]
    J -->|"Some labels"| L["Semi-supervised learning"]
    J -->|"No labels"| M["Unsupervised or self-supervised"]

Construa

O código em code/ml_intro.py implementa um classificador centróide mais próximo do zero, o algoritmo de ML mais simples possível. Ele demonstra a ideia central: aprender com os dados e depois prever com base em novos dados.

Etapa 1: Classificador Centróide mais próximo do zero

O classificador centróide mais próximo calcula o centro (média) de cada classe nos dados de treinamento. Para prever, atribui cada novo ponto à classe cujo centro está mais próximo.

class NearestCentroid:
    def fit(self, X, y):
        self.classes = np.unique(y)
        self.centroids = np.array([
            X[y == c].mean(axis=0) for c in self.classes
        ])

    def predict(self, X):
        distances = np.array([
            np.sqrt(((X - c) ** 2).sum(axis=1))
            for c in self.centroids
        ])
        return self.classes[distances.argmin(axis=0)]

Esse é todo o algoritmo. O Fit calcula duas médias. Prever calcula distâncias. Sem descida do gradiente, sem iteração, sem hiperparâmetros.

Etapa 2: treinar com dados sintéticos

Geramos um conjunto de dados de classificação 2D com duas classes que se sobrepõem ligeiramente. O classificador centróide traça um limite de decisão linear entre os centros de classe.

rng = np.random.RandomState(42)
X_class0 = rng.randn(100, 2) + np.array([1.0, 1.0])
X_class1 = rng.randn(100, 2) + np.array([-1.0, -1.0])
X = np.vstack([X_class0, X_class1])
y = np.array([0] * 100 + [1] * 100)

Etapa 3: compare com uma linha de base

Cada modelo de ML deve ser comparado com uma linha de base trivial. Aqui, a linha de base prevê uma classe aleatória. Se o seu modelo de ML não supera as suposições aleatórias, algo está errado.

baseline_preds = rng.choice([0, 1], size=len(y_test))
baseline_acc = np.mean(baseline_preds == y_test)

O classificador centróide deve obter cerca de 90%+ de precisão neste conjunto de dados limpo. A linha de base aleatória fica em torno de 50%.

Por que isso é importante

O classificador centróide mais próximo é trivialmente simples. Não possui hiperparâmetros, nem iteração, nem gradiente descendente. No entanto, ele captura o padrão fundamental de ML:

1. Aprenda uma representação dos dados de treinamento (os centróides)
2. Prever novos dados usando essa representação (distância mais próxima)
3. Avaliar em relação a uma linha de base (suposição aleatória)

Todo algoritmo de ML, desde regressão logística até transformadores, segue esse mesmo padrão de três etapas. A representação fica mais complexa, mas o fluxo de trabalho permanece o mesmo.

Etapa 4: O que o classificador Centroid não pode fazer

O classificador centróide mais próximo assume que cada classe forma um único blob. Ele desenha limites de decisão lineares. Ele falha quando:

• As classes possuem múltiplos clusters (por exemplo, o dígito “1” pode ser escrito de diversas maneiras diferentes)
• O limite de decisão é não linear (por exemplo, uma classe envolve outra)
• As feições têm escalas muito diferentes (a distância é dominada pela feição de maior escala)

Essas limitações motivam todos os outros algoritmos que você aprenderá. K-vizinhos mais próximos lidam com vários clusters. As árvores de decisão lidam com limites não lineares. A escala de recursos corrige o problema de escala. Cada lição se baseia nas limitações da anterior.

Use-o

sklearn fornece NearestCentroid e geradores de dados sintéticos:

from sklearn.neighbors import NearestCentroid
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(
    n_samples=500, n_features=2, n_redundant=0,
    n_clusters_per_class=1, random_state=42
)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

clf = NearestCentroid()
clf.fit(X_train, y_train)
print(f"Accuracy: {clf.score(X_test, y_test):.3f}")

Envie

Esta lição produz outputs/prompt-ml-problem-framer.md – um prompt que transforma vagos problemas de negócios em tarefas concretas de ML. Forneça uma descrição do problema (“queremos reduzir a rotatividade” ou “prever a demanda para o próximo trimestre”) e ele identifica o tipo de aprendizagem, define a meta de previsão, lista os recursos candidatos, escolhe uma métrica de sucesso, estabelece uma linha de base e sinaliza armadilhas como vazamento de dados ou desequilíbrio de classe. Use-o no início de qualquer projeto de ML para evitar criar algo errado.

Termos-chave

Exercícios

1. Pegue qualquer conjunto de dados (por exemplo, Iris, Titanic). Divida 70/15/15 em treinamento/validação/teste. Explique por que você não deve ajustar hiperparâmetros no conjunto de testes.
2. Liste três problemas do mundo real. Para cada um, identifique se é classificação, regressão ou agrupamento e se é supervisionado ou não supervisionado.
3. Um modelo obtém 99% de precisão nos dados de treinamento, mas 60% nos dados de teste. Diagnosticar o problema e listar três coisas que você tentaria resolver.

Leitura Adicional

• Uma Introdução à Aprendizagem Estatística - livro gratuito que cobre todos os métodos clássicos de ML com exemplos práticos
• Curso intensivo de aprendizado de máquina do Google - introdução visual concisa aos conceitos de ML
• Scikit-learn Guia do usuário - a referência prática para implementação de ML em Python