O Segredo dos Dados de Qualidade
Se existe uma verdade universal em Machine Learning, é esta: garbage in, garbage out (lixo entra, lixo sai).
Não importa quão sofisticado seja seu algoritmo - se os dados forem ruins, os resultados serão piores ainda. Nesta aula, você vai aprender como transformar dados brutos em ouro puro para IA.
O que você vai aprender:
1. Coleta Inteligente: Onde encontrar e como extrair dados de qualidade
2. Limpeza Profissional: Técnicas para eliminar ruídos e inconsistências
3. Preparação Otimizada: Formatar dados para máxima performance
4. Validação de Qualidade: Como garantir que seus dados estão prontos
5. Ferramentas Práticas: Código Python real que você vai usar
Coleta de Dados: O Primeiro Passo Crítico
1
Definir Objetivos
Antes de coletar qualquer coisa, saiba exatamente o que você quer resolver.
- Qual problema a IA vai resolver?
- Que tipo de previsão você precisa?
- Quais variáveis são importantes?
2
Identificar Fontes
Mapeie onde estão os dados que você precisa:
- Dados Internos: Seu sistema, planilhas, relatórios
- APIs Públicas: Twitter, Reddit, governo, weather
- Web Scraping: Sites públicos (cuidado com términos)
- Datasets Públicos: Kaggle, UCI, Google Datasets
3
Extração Automática
Use código Python para automatizar a coleta:
import pandas as pd
import requests
from bs4 import BeautifulSoup
# Exemplo: Coletar dados de API
def coletar_dados_api(url, parametros):
response = requests.get(url, params=parametros)
if response.status_code == 200:
return pd.DataFrame(response.json())
return None
# Exemplo: Web scraping simples
def coletar_dados_web(url, classe_css):
response = requests.get(url)
soup = BeautifulSoup(response.content, 'html.parser')
dados = soup.find_all('div', class_=classe_css)
return [item.text.strip() for item in dados]
Limpeza de Dados: Transformando Caos em Ordem
Esta é a parte onde você vai gastar 70% do seu tempo. Mas é aqui que a mágica acontece!
Problemas Comuns e Soluções
1. Valores Faltantes (NaN, null, vazios)
# Identificar valores faltantes
print(df.isnull().sum())
# Estratégias para lidar:
# - Remover linhas com muitos faltantes
df_clean = df.dropna(thresh=len(df.columns) * 0.7)
# - Preencher com média/mediana
df['idade'].fillna(df['idade'].median(), inplace=True)
# - Preencher com valor mais frequente
df['categoria'].fillna(df['categoria'].mode()[0], inplace=True)
2. Dados Duplicados
# Encontrar duplicatas
print(f"Duplicatas encontradas: {df.duplicated().sum()}")
# Remover duplicatas mantendo o primeiro
df_clean = df.drop_duplicates(keep='first')
# Duplicatas baseadas em colunas específicas
df_clean = df.drop_duplicates(subset=['email', 'cpf'])
3. Dados Inconsistentes
# Padronizar texto
df['nome'] = df['nome'].str.lower().str.strip()
df['nome'] = df['nome'].str.title()
# Padronizar datas
df['data'] = pd.to_datetime(df['data'], format='%d/%m/%Y')
# Categorias inconsistentes
mapeamento = {'M': 'Masculino', 'F': 'Feminino', 'male': 'Masculino'}
df['sexo'] = df['sexo'].map(mapeamento)
Preparação para Machine Learning
1. Encoding de Variáveis Categóricas
IA só entende números. Vamos converter texto em números:
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
# Label Encoding (para variáveis ordinais)
le = LabelEncoder()
df['tamanho_encoded'] = le.fit_transform(df['tamanho']) # P, M, G -> 0, 1, 2
# One-Hot Encoding (para variáveis nominais)
df_encoded = pd.get_dummies(df, columns=['cor'], prefix='cor')
# cor_azul, cor_vermelho, cor_verde (0 ou 1)
2. Normalização e Padronização
Colocar todas as variáveis na mesma escala:
from sklearn.preprocessing import StandardScaler, MinMaxScaler
# Padronização (média=0, desvio=1)
scaler = StandardScaler()
df_scaled = scaler.fit_transform(df[['idade', 'renda']])
# Normalização (valores entre 0 e 1)
normalizer = MinMaxScaler()
df_normalized = normalizer.fit_transform(df[['preco', 'quantidade']])
3. Divisão de Dados
Separar dados para treino, validação e teste:
from sklearn.model_selection import train_test_split
# Divisão simples (80% treino, 20% teste)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
# Divisão tripla (60% treino, 20% validação, 20% teste)
X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.4)
X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5)
Validação de Qualidade dos Dados
Checklist de Qualidade
Antes de treinar qualquer modelo, verifique:
- Menos de 5% de valores faltantes por coluna
- Sem duplicatas desnecessárias
- Variáveis categóricas codificadas
- Outliers identificados e tratados
- Dados balanceados (ou estratégia para desbalanceio)
- Correlações muito altas removidas (>0.95)
# Função completa de validação
def validar_dados(df, target_col):
"""Valida a qualidade dos dados para ML"""
print("=== RELATÓRIO DE QUALIDADE DOS DADOS ===")
# 1. Informações gerais
print(f"\n📊 Shape: {df.shape}")
print(f"📊 Colunas: {list(df.columns)}")
# 2. Valores faltantes
missing = df.isnull().sum()
missing_pct = (missing / len(df)) * 100
print(f"\n❌ Valores faltantes:")
for col, pct in missing_pct[missing_pct > 0].items():
print(f" {col}: {pct:.1f}%")
# 3. Duplicatas
duplicates = df.duplicated().sum()
print(f"\n🔄 Duplicatas: {duplicates}")
# 4. Tipos de dados
print(f"\n🔢 Tipos de dados:")
print(df.dtypes.value_counts())
# 5. Balanceamento da variável target
if target_col in df.columns:
print(f"\n⚖️ Distribuição do target '{target_col}':")
print(df[target_col].value_counts(normalize=True) * 100)
return True
Projeto Prático: Dataset Completo
Vamos criar um projeto real usando dados do Airbnb:
# Projeto: Prever preço de imóveis Airbnb
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler, LabelEncoder
# 1. Carregar dados
url = "http://data.insideairbnb.com/united-states/ny/new-york-city/2023-12-04/data/listings.csv.gz"
df = pd.read_csv(url)
# 2. Seleção de features relevantes
features = ['neighbourhood_group', 'room_type', 'minimum_nights',
'number_of_reviews', 'availability_365', 'price']
df_clean = df[features].copy()
# 3. Limpeza da coluna preço
df_clean['price'] = df_clean['price'].str.replace('$', '').str.replace(',', '')
df_clean['price'] = pd.to_numeric(df_clean['price'], errors='coerce')
# 4. Remover outliers extremos (acima do percentil 95)
price_95 = df_clean['price'].quantile(0.95)
df_clean = df_clean[df_clean['price'] <= price_95]
# 5. Tratar valores faltantes
df_clean = df_clean.dropna()
# 6. Encoding de categóricas
le_neighborhood = LabelEncoder()
le_room = LabelEncoder()
df_clean['neighbourhood_encoded'] = le_neighborhood.fit_transform(df_clean['neighbourhood_group'])
df_clean['room_type_encoded'] = le_room.fit_transform(df_clean['room_type'])
# 7. Preparar features finais
features_finais = ['neighbourhood_encoded', 'room_type_encoded',
'minimum_nights', 'number_of_reviews', 'availability_365']
X = df_clean[features_finais]
y = df_clean['price']
print("✅ Dataset preparado com sucesso!")
print(f"📊 Shape final: {X.shape}")
print(f"🎯 Target shape: {y.shape}")
Teste Seu Conhecimento
Vamos verificar o que você aprendeu sobre preparação de dados!
Resumo da Aula
O que você dominou hoje:
- Como identificar e coletar dados de qualidade
- Técnicas profissionais de limpeza de dados
- Preparação otimizada para Machine Learning
- Validação completa da qualidade dos dados
- Projeto real com dados do Airbnb
Próxima Aula
Com seus dados limpos e preparados, chegou a hora de criar seu primeiro modelo de Machine Learning do zero! Vamos usar scikit-learn para construir algo que realmente funciona.
Isaque Victor cursos gratuitos