Introdução ao machine learning com Python

1. Fundamentos do Machine Learning

Machine learning (aprendizado de máquina) é um subcampo da inteligência artificial que permite que sistemas aprendam e melhorem a partir de experiência sem serem explicitamente programados. Diferentemente da programação tradicional, onde escrevemos regras fixas para processar dados e gerar saídas, no ML fornecemos exemplos e o algoritmo descobre padrões automaticamente.

Os principais tipos de aprendizado são:

  • Supervisionado: trabalha com dados rotulados (ex: classificar e-mails como spam ou não spam)
  • Não supervisionado: encontra padrões em dados não rotulados (ex: segmentação de clientes)
  • Por reforço: agente aprende por tentativa e erro com recompensas (ex: jogos, robótica)

O ciclo de vida de um projeto de ML envolve: coleta de dados, preparação, treinamento do modelo, avaliação e implantação. Vamos percorrer cada etapa com Python.

2. Configuração do Ambiente Python para ML

Primeiro, configure um ambiente isolado:

python -m venv ml_env
source ml_env/bin/activate  # Linux/Mac
ml_env\Scripts\activate     # Windows

Instale as bibliotecas essenciais:

pip install numpy pandas matplotlib seaborn scikit-learn jupyter

Verifique as instalações:

import numpy as np
import pandas as pd
import sklearn
print(f"NumPy: {np.__version__}")
print(f"Pandas: {pd.__version__}")
print(f"Scikit-learn: {sklearn.__version__}")

3. Manipulação e Exploração de Dados

Vamos carregar o dataset Iris, clássico para iniciantes:

import pandas as pd
import numpy as np

# Carregar dataset do seaborn
import seaborn as sns
df = sns.load_dataset('iris')
print(df.head())
print(df.info())
print(df.describe())

Análise exploratória básica:

# Verificar valores nulos
print(df.isnull().sum())

# Estatísticas por classe
print(df.groupby('species').mean())

# Visualização rápida
import matplotlib.pyplot as plt
df.hist(figsize=(10, 8))
plt.tight_layout()
plt.show()

Matriz de correlação:

corr = df.drop('species', axis=1).corr()
sns.heatmap(corr, annot=True, cmap='coolwarm')
plt.title('Matriz de Correlação')
plt.show()

4. Pré-processamento e Limpeza de Dados

Para demonstrar tratamento de valores ausentes, vamos criar um cenário simulado:

# Simular dados faltantes
df_clean = df.copy()
df_clean.loc[0:5, 'sepal_width'] = np.nan

# Remoção simples
df_drop = df_clean.dropna()

# Imputação com mediana
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='median')
df_imputed = pd.DataFrame(imputer.fit_transform(df_clean.drop('species', axis=1)),
                          columns=df_clean.columns[:-1])

Codificação de variáveis categóricas:

from sklearn.preprocessing import LabelEncoder, OneHotEncoder

# Label Encoding
le = LabelEncoder()
df['species_encoded'] = le.fit_transform(df['species'])
print(df[['species', 'species_encoded']].head())

# One-Hot Encoding
one_hot = pd.get_dummies(df['species'], prefix='species')
df_encoded = pd.concat([df.drop('species', axis=1), one_hot], axis=1)

Normalização e padronização:

from sklearn.preprocessing import StandardScaler, MinMaxScaler

scaler_std = StandardScaler()
scaler_minmax = MinMaxScaler()

features = df.drop('species', axis=1).select_dtypes(include=[np.number])
X_std = scaler_std.fit_transform(features)
X_minmax = scaler_minmax.fit_transform(features)

print("Média após padronização:", X_std.mean(axis=0).round(2))
print("Desvio padrão:", X_std.std(axis=0).round(2))

5. Primeiro Modelo de Classificação com scikit-learn

Vamos criar um classificador KNN:

from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Preparar dados
X = df.drop('species', axis=1).select_dtypes(include=[np.number])
y = df['species']

# Divisão treino-teste
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

print(f"Treino: {X_train.shape}, Teste: {X_test.shape}")

# Criar e treinar modelo
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)

# Predizer
y_pred = knn.predict(X_test)
print(f"Acurácia: {accuracy_score(y_test, y_pred):.2f}")

6. Avaliação e Métricas de Desempenho

Matriz de confusão e métricas detalhadas:

from sklearn.metrics import confusion_matrix, classification_report

# Matriz de confusão
cm = confusion_matrix(y_test, y_pred)
print("Matriz de Confusão:")
print(cm)

# Relatório completo
print("\nRelatório de Classificação:")
print(classification_report(y_test, y_pred))

# Validação cruzada
from sklearn.model_selection import cross_val_score
scores = cross_val_score(knn, X, y, cv=5)
print(f"Acurácia CV: {scores.mean():.2f} (+/- {scores.std()*2:.2f})")

7. Introdução a Regressão com Python

Vamos usar o dataset Boston Housing para regressão:

from sklearn.datasets import load_diabetes
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# Carregar dados
data = load_diabetes()
X_reg = data.data
y_reg = data.target

# Dividir
X_train_r, X_test_r, y_train_r, y_test_r = train_test_split(
    X_reg, y_reg, test_size=0.2, random_state=42
)

# Treinar regressão linear
lr = LinearRegression()
lr.fit(X_train_r, y_train_r)

# Predizer
y_pred_r = lr.predict(X_test_r)

# Métricas
mse = mean_squared_error(y_test_r, y_pred_r)
r2 = r2_score(y_test_r, y_pred_r)

print(f"MSE: {mse:.2f}")
print(f"R²: {r2:.2f}")
print(f"Coeficientes: {lr.coef_[:5]}...")

8. Próximos Passos e Boas Práticas

Salvar e carregar modelos:

import joblib

# Salvar
joblib.dump(knn, 'modelo_knn.pkl')
joblib.dump(scaler_std, 'scaler.pkl')

# Carregar
modelo_carregado = joblib.load('modelo_knn.pkl')
scaler_carregado = joblib.load('scaler.pkl')

Criar pipelines para automatizar:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', KNeighborsClassifier(n_neighbors=5))
])

pipeline.fit(X_train, y_train)
print(f"Acurácia pipeline: {pipeline.score(X_test, y_test):.2f}")

Para aprofundamento, explore competições no Kaggle, estude a documentação oficial do scikit-learn e pratique com datasets reais. O aprendizado contínuo é essencial — machine learning é uma área que evolui rapidamente.

Referências