Aula 2 - Entendendo Dados para IA - Coleta e Preparação

📊 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

🔍 Tipos de Dados para IA

📝

Dados Estruturados

Planilhas, bancos de dados, CSVs. Organizados em linhas e colunas.

Exemplos: Vendas, preços, idades

📄

Dados Não-Estruturados

Texto livre, imagens, áudios, vídeos. Sem formato fixo.

Exemplos: Emails, reviews, fotos

⚡

Dados em Tempo Real

Streams contínuos de informação que mudam constantemente.

Exemplos: Sensores, logs, transações

🎣 Coleta de Dados: O Primeiro Passo Crítico

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?

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

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!

Warning: foreach() argument must be of type array|object, string given in /home3/ivar2024iv/isaquevictor.com/cursos/components/Quiz.php on line 60

📚 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.

Entendendo Dados para IA - Coleta e Preparação