Machine Learning com Python — 2025 | Python Brasil | Python Brasil

Machine Learning deixou de ser um tema exclusivo de pesquisadores e se tornou uma habilidade cada vez mais requisitada no mercado. Com Python e a biblioteca scikit-learn, voce consegue construir modelos de classificacao, regressao e agrupamento de forma acessivel. Neste guia, a gente vai explorar os conceitos fundamentais e construir modelos reais passo a passo.

O Que e Machine Learning?

Machine Learning e um ramo da inteligencia artificial onde algoritmos aprendem padroes a partir de dados, sem serem explicitamente programados para cada regra. Existem tres tipos principais: aprendizado supervisionado (com respostas conhecidas), nao-supervisionado (sem respostas) e por reforco (aprendizado por tentativa e erro).

Neste artigo, vamos focar no aprendizado supervisionado, que e o mais comum na pratica.

Configurando o Ambiente

Instale as bibliotecas necessarias:

pip install scikit-learn pandas numpy matplotlib

Primeiro Modelo: Classificacao

Vamos construir um classificador que identifica tipos de flores usando o famoso dataset Iris:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, accuracy_score
import pandas as pd

# Carregar dados
iris = load_iris()
X = pd.DataFrame(iris.data, columns=iris.feature_names)
y = iris.target

print("Formato dos dados:", X.shape)
print("Classes:", iris.target_names)
print(X.head())

# Dividir em treino e teste
X_treino, X_teste, y_treino, y_teste = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print(f"\nDados de treino: {X_treino.shape[0]} amostras")
print(f"Dados de teste: {X_teste.shape[0]} amostras")

# Treinar modelo
modelo = RandomForestClassifier(n_estimators=100, random_state=42)
modelo.fit(X_treino, y_treino)

# Avaliar
previsoes = modelo.predict(X_teste)
acuracia = accuracy_score(y_teste, previsoes)
print(f"\nAcuracia: {acuracia:.2%}")
print("\nRelatorio detalhado:")
print(classification_report(y_teste, previsoes, target_names=iris.target_names))

Entendendo o Fluxo de Trabalho

Todo projeto de Machine Learning segue um fluxo similar:

Coleta e exploracao dos dados
Pre-processamento e limpeza
Divisao em treino e teste
Treinamento do modelo
Avaliacao de performance
Ajuste de hiperparametros
Deploy do modelo

Vamos seguir esse fluxo com um exemplo mais completo.

Exemplo Pratico: Prevendo Precos de Imoveis

Agora vamos trabalhar com regressao para prever valores numericos:

from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_absolute_error, r2_score
import pandas as pd
import numpy as np

# Carregar dados de imoveis da California
dados = fetch_california_housing()
X = pd.DataFrame(dados.data, columns=dados.feature_names)
y = dados.target  # Preco em centenas de milhares de dolares

print("Primeiras linhas dos dados:")
print(X.head())
print(f"\nEstatisticas do preco alvo:")
print(f"  Media: ${np.mean(y) * 100_000:,.0f}")
print(f"  Mediana: ${np.median(y) * 100_000:,.0f}")

Pre-processamento

# Normalizar features (importante para muitos algoritmos)
scaler = StandardScaler()

X_treino, X_teste, y_treino, y_teste = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Fit no treino, transform em ambos
X_treino_scaled = scaler.fit_transform(X_treino)
X_teste_scaled = scaler.transform(X_teste)

print(f"Media antes: {X_treino.iloc[:, 0].mean():.2f}")
print(f"Media depois: {X_treino_scaled[:, 0].mean():.6f}")

Comparando Modelos

# Modelo 1: Regressao Linear
modelo_linear = LinearRegression()
modelo_linear.fit(X_treino_scaled, y_treino)
previsoes_linear = modelo_linear.predict(X_teste_scaled)

# Modelo 2: Gradient Boosting
modelo_gb = GradientBoostingRegressor(
    n_estimators=200,
    max_depth=4,
    learning_rate=0.1,
    random_state=42
)
modelo_gb.fit(X_treino_scaled, y_treino)
previsoes_gb = modelo_gb.predict(X_teste_scaled)

# Comparar resultados
print("=== Regressao Linear ===")
print(f"MAE: ${mean_absolute_error(y_teste, previsoes_linear) * 100_000:,.0f}")
print(f"R2 Score: {r2_score(y_teste, previsoes_linear):.4f}")

print("\n=== Gradient Boosting ===")
print(f"MAE: ${mean_absolute_error(y_teste, previsoes_gb) * 100_000:,.0f}")
print(f"R2 Score: {r2_score(y_teste, previsoes_gb):.4f}")

Validacao Cruzada

Para avaliacoes mais robustas, use cross-validation:

from sklearn.model_selection import cross_val_score

scores = cross_val_score(
    modelo_gb, X_treino_scaled, y_treino,
    cv=5, scoring="r2"
)

print(f"R2 por fold: {scores}")
print(f"R2 medio: {scores.mean():.4f} (+/- {scores.std():.4f})")

Importancia das Features

Entender quais variaveis mais influenciam o modelo e essencial:

import pandas as pd

# Features mais importantes (Gradient Boosting)
importancias = pd.Series(
    modelo_gb.feature_importances_,
    index=dados.feature_names
).sort_values(ascending=False)

print("Importancia das features:")
for feature, imp in importancias.items():
    barra = "#" * int(imp * 50)
    print(f"  {feature:20s} {imp:.4f} {barra}")

Pipeline: Organizando o Fluxo

Scikit-learn oferece Pipelines para encadear pre-processamento e modelo:

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

# Criar pipeline
pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("modelo", RandomForestRegressor(n_estimators=100, random_state=42))
])

# Treinar e prever em um passo
pipeline.fit(X_treino, y_treino)
previsoes = pipeline.predict(X_teste)
print(f"R2 Score: {r2_score(y_teste, previsoes):.4f}")

# Validacao cruzada com pipeline
scores = cross_val_score(pipeline, X, y, cv=5, scoring="r2")
print(f"R2 medio (CV): {scores.mean():.4f}")

Salvando e Carregando Modelos

Para reutilizar modelos treinados:

import joblib

# Salvar modelo treinado
joblib.dump(pipeline, "modelo_imoveis.joblib")
print("Modelo salvo!")

# Carregar modelo
modelo_carregado = joblib.load("modelo_imoveis.joblib")

# Fazer previsao com novo dado
novo_imovel = [[8.3, 41.0, 6.9, 1.02, 322.0, 2.55, 37.88, -122.23]]
preco_previsto = modelo_carregado.predict(novo_imovel)
print(f"Preco previsto: ${preco_previsto[0] * 100_000:,.0f}")

Tratando Dados Faltantes

Dados reais frequentemente tem valores ausentes:

from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline

# Pipeline com tratamento de dados faltantes
pipeline_completo = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler()),
    ("modelo", GradientBoostingRegressor(n_estimators=200, random_state=42))
])

# Funciona mesmo com NaN nos dados
pipeline_completo.fit(X_treino, y_treino)

Metricas de Avaliacao

Escolher a metrica certa depende do problema:

from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    mean_absolute_error, mean_squared_error, r2_score
)

# Para classificacao
print("=== Metricas de Classificacao ===")
print(f"Acuracia: proporcao de acertos totais")
print(f"Precisao: dos positivos previstos, quantos sao corretos")
print(f"Recall: dos positivos reais, quantos foram detectados")
print(f"F1-Score: media harmonica entre precisao e recall")

# Para regressao
print("\n=== Metricas de Regressao ===")
print(f"MAE: erro medio absoluto (mais interpretavel)")
print(f"MSE: erro medio quadratico (penaliza erros grandes)")
print(f"R2: proporcao da variancia explicada pelo modelo")

Boas Praticas

Ao trabalhar com Machine Learning em Python, siga estas recomendacoes:

Sempre divida os dados em treino e teste antes de qualquer pre-processamento
Use cross-validation para avaliacoes mais confiaveis
Normalize os dados quando usar algoritmos sensiveis a escala
Comece com modelos simples e aumente a complexidade gradualmente
Documente os hiperparametros e resultados de cada experimento
Cuidado com overfitting: monitore a diferenca entre treino e teste
Use Pipelines para manter o codigo organizado e reproduzivel

Conclusao

Machine Learning com Python e scikit-learn e acessivel e poderoso. Com os conceitos de classificacao, regressao, pre-processamento e avaliacao apresentados neste guia, voce tem uma base solida para comecar seus projetos. Pratique com datasets publicos, explore diferentes algoritmos e lembre-se de que a qualidade dos dados e tao importante quanto a escolha do modelo.

Machine Learning com Python — 2025 | Python Brasil