Primeiros Passos

Primeiros Passos com Machine Learning em Python

Este capítulo apresenta o machine learning com Python. Você aprenderá o que é machine learning, por que Python é a linguagem dominante para isso, como configurar um ambiente de trabalho e como o fluxo de trabalho de ML de ponta a ponta se encaixa — desde dados brutos até um modelo treinado e avaliado.

Ao final, você terá executado um exemplo completo de classificação usando as três bibliotecas principais: NumPy, pandas e scikit-learn.

O que é Machine Learning?

Machine learning (ML) é um ramo da inteligência artificial em que um programa aprende padrões a partir de dados em vez de seguir regras escritas manualmente. Você fornece exemplos (dados), especifica o que deseja prever ou descobrir, e um algoritmo de ML encontra o mapeamento.

Existem três categorias amplas:

Esta série foca no aprendizado supervisionado porque é a categoria mais amplamente usada na prática.

Por que Python para Machine Learning?

Python se tornou a linguagem padrão para ML por vários motivos:

• Sintaxe legível — algoritmos podem ser prototipados rapidamente sem código repetitivo.
• Ecossistema rico — scikit-learn, TensorFlow, PyTorch e Keras têm APIs Python de primeira classe.
• Ferramentas de dados — NumPy e pandas tornam o tratamento de dados simples.
• Comunidade — a maior comunidade de ML, o que significa tutoriais abundantes, respostas no Stack Overflow e modelos pré-treinados.

Configurando Seu Ambiente

Instalar Python

Baixe Python 3.10 ou mais recente em python.org. Verifique a instalação:

python3 --version

Você deverá ver uma saída como Python 3.10.15 (ou mais recente).

Criar um Ambiente Virtual

Um ambiente virtual isola os pacotes do seu projeto da instalação do sistema Python. Isso evita conflitos de versão entre projetos.

python3 -m venv ml-env

Ative-o:

# macOS / Linux
source ml-env/bin/activate

# Windows (Command Prompt)
ml-env\Scripts\activate.bat

Seu prompt agora mostrará (ml-env) para confirmar que o ambiente está ativo.

Instalar as Bibliotecas Principais

Com o ambiente virtual ativo, instale as três bibliotecas que você usará ao longo desta série:

pip install numpy pandas scikit-learn

Salve as versões exatas para reprodutibilidade:

pip freeze > requirements.txt

Qualquer pessoa que clonar seu projeto poderá reproduzir seu ambiente com pip install -r requirements.txt.

O Fluxo de Trabalho de Machine Learning

Todo projeto de ML supervisionado segue o mesmo pipeline de cinco etapas:

Raw data → Clean & prepare → Split → Train model → Evaluate

Entender este pipeline é mais importante do que memorizar qualquer algoritmo individual. As seções abaixo percorrem cada etapa com código.

Etapa 1 — Entenda Seus Dados com NumPy e pandas

Antes de treinar qualquer coisa, você precisa saber como seus dados se parecem. NumPy fornece aritmética rápida de arrays; pandas adiciona tabelas rotuladas (DataFrames) que facilitam a exploração.

NumPy: inspecionando um array numérico

import numpy as np

data = np.array([2.1, 3.4, 1.8, 5.0, 2.7])
print('Mean:', data.mean())   # 3.0
print('Std: ', round(data.std(), 4))  # 1.1402
print('Max: ', data.max())    # 5.0

pandas: construindo um pequeno conjunto de dados

import pandas as pd

df = pd.DataFrame({
    'age':    [25, 30, 22, 35, 28],
    'income': [40000, 55000, 32000, 70000, 48000],
    'bought': [0,     1,     0,     1,     0],
})

print(df.shape)             # (5, 3)
print(df['income'].mean())  # 49000.0
print(df.isnull().sum())    # 0 missing values in each column

df.shape informa o número de linhas e colunas. isnull().sum() conta os valores ausentes por coluna — sempre verifique isso antes de modelar.

Etapa 2 — Limpar e Preparar os Dados

Conjuntos de dados reais quase sempre têm valores ausentes, formatos inconsistentes ou recursos em escalas muito diferentes. Você precisa resolver isso antes do treinamento.

Tratar Valores Ausentes

Substitua números ausentes pela mediana da coluna (robusta a outliers) ou pela média:

import pandas as pd

df = pd.DataFrame({
    'age':    [25, None, 22, 35, 28],
    'income': [40000, 55000, None, 70000, 48000],
})

df['age']    = df['age'].fillna(df['age'].median())
df['income'] = df['income'].fillna(df['income'].mean())

print(df.isnull().sum())
# age       0
# income    0

Escalar Recursos

Muitos algoritmos (k-vizinhos mais próximos, SVMs, redes neurais) são sensíveis à escala dos recursos. Uma coluna com valores na casa dos milhares dominará uma coluna com dígitos simples a menos que você as normalize. StandardScaler subtrai a média e divide pelo desvio padrão, de modo que cada recurso tem média 0 e desvio padrão 1:

from sklearn.preprocessing import StandardScaler
import numpy as np

X = np.array([[1.0, 200.0], [2.0, 400.0], [3.0, 300.0]])
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
print(X_scaled.round(2))
# [[-1.22 -1.22]
#  [ 0.    1.22]
#  [ 1.22  0.  ]]

Veja Feature Scaling para mais detalhes.

Etapa 3 — Dividir em Conjuntos de Treinamento e Teste

Nunca avalie um modelo nos dados em que foi treinado — seria como corrigir sua própria prova com o gabarito à vista. Divida os dados para que o modelo treine em uma parte e seja avaliado em uma parte separada que nunca viu.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

test_size=0.2 reserva 20% dos dados para teste. random_state=42 torna a divisão reproduzível. Veja o capítulo Train/Test Split para estratégias como divisão estratificada e validação cruzada.

Etapa 4 — Treinar um Modelo

Com dados limpos e divididos, você pode treinar seu primeiro modelo. O exemplo abaixo usa o conjunto de dados Iris — um benchmark clássico com 150 amostras, 4 recursos numéricos e 3 espécies de flores para classificar.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# 1. Load
iris = load_iris()

# 2. Split
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

# 3. Train
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 4. Predict & evaluate
predictions = model.predict(X_test)
print(f'Test samples: {len(X_test)}')   # 30
print(f'Accuracy: {accuracy_score(y_test, predictions):.2f}')  # 1.00

Um RandomForestClassifier treina muitas árvores de decisão em subconjuntos aleatórios dos dados e combina os votos delas. Ele lida bem com relações não lineares e é uma linha de base sólida para tarefas de classificação. n_estimators=100 especifica o número de árvores.

Etapa 5 — Avaliar o Modelo

A acurácia (a proporção de previsões corretas) é fácil de entender, mas pode ser enganosa quando uma classe é muito mais rara do que as outras. O scikit-learn fornece um conjunto completo de métricas:

Para uma análise mais aprofundada da avaliação, veja o capítulo Confusion Matrix.

Escolhendo o Algoritmo Certo

Problemas diferentes exigem algoritmos diferentes. Aqui está uma orientação rápida:

Você explorará a maioria deles no restante desta série. Bons pontos de partida são K-Nearest Neighbors, Decision Tree e Linear Regression.

Armadilhas para Iniciantes

• Vazamento de dados — ajustar o scaler no conjunto de dados completo (antes da divisão) vaza estatísticas do conjunto de teste para o treinamento. Sempre ajuste os transformadores apenas no conjunto de treinamento e depois aplique-os ao conjunto de teste.
• Overfitting — um modelo que memoriza os dados de treinamento tem desempenho ruim em dados novos. Use Cross-Validation para detectar isso cedo.
• Ignorar desequilíbrio de classes — se 95% dos seus rótulos são "negativo", um modelo que sempre prevê "negativo" marca 95% de acurácia mas é inútil. Verifique a distribuição das classes antes de escolher uma métrica.
• Pular a exploração — sempre examine seus dados antes de modelar. Verifique intervalos, distribuições e contagens de valores ausentes.

Conclusão

Você agora tem um ambiente Python de ML funcional e entende o pipeline completo de aprendizado supervisionado: carregar dados, limpá-los, dividi-los, treinar um modelo e avaliar em dados separados. Os capítulos seguintes aprofundam cada etapa — começando com preparação de dados, passando pelos algoritmos individuais e finalizando com tópicos avançados como validação cruzada e ajuste de hiperparâmetros.