Projeto 1

Grupo 3 / Os Goats do SI

1. José Longo Neto
2. Pedro Almeida Maricate
3. Martim Ponzio
4. Pablo Dimitrof
5. Enzo Malagoli
6. Eduardo Gul

Introdução

O objetivo deste projeto é aplicar três algoritmos de Machine Learning — Árvore de Decisão, K-Nearest Neighbors (KNN) e K-Means (Clustering) — sobre a base de dados do kagle.
A base contém aproximadamente 130 mil registros de vinhos, com informações como país de origem, pontuação atribuída por especialistas, preço, tipo de uva, região produtora e descrição sensorial.

A proposta é explorar o uso de algoritmos de aprendizado supervisionado e não supervisionado para compreender padrões entre as variáveis e identificar possíveis relações entre características como origem, variedade e pontuação dos vinhos.

O roteiro segue a mesma estrutura aplicada em outros projetos da disciplina, dividindo o processo em etapas sequenciais e documentadas:

• Exploração dos Dados (EDA): análise geral das variáveis, distribuição de valores e identificação de possíveis inconsistências;
• Pré-processamento: limpeza, padronização e codificação de dados categóricos;
• Divisão dos Dados: separação em conjuntos de treino e teste, quando houver variável-alvo definida;
• Treinamento e Avaliação: aplicação e comparação dos modelos supervisionados (Árvore de Decisão e KNN);
• Modelagem Não Supervisionada: uso do K-Means para identificar agrupamentos entre os vinhos sem utilizar o rótulo de pontuação;
• Relatório Final e Comparação: discussão sobre os resultados obtidos e limitações de cada abordagem.

Observação:
O dataset não possui uma coluna explicitamente binária de qualidade, mas contém a variável points, que representa a nota do vinho atribuída por avaliadores.
Para fins de classificação, esta variável será transformada em uma variável-alvo derivada, categorizando os vinhos conforme sua pontuação (por exemplo, alta pontuação ≥ 90).
Assim, os modelos supervisionados trabalharão com essa classificação, enquanto o K-Means será utilizado para detectar padrões de agrupamento sem rótulos.

Exploração dos Dados

A etapa de Exploração dos Dados (EDA) tem como objetivo compreender a estrutura, o conteúdo e o significado das variáveis presentes na base wine.csv.
Essa análise inicial permite identificar padrões, outliers, distribuições e possíveis problemas de qualidade dos dados, como valores ausentes ou inconsistências.
As visualizações e descrições abaixo ajudam a construir uma visão geral do conjunto e a orientar as etapas seguintes de pré-processamento e modelagem.

Pré-processamento

Após a exploração inicial, aplicamos um conjunto de procedimentos para preparar a base wine.csv para modelagem:

• Remoção de colunas irrelevantes: descartamos campos sem utilidade direta para o modelo ou que serão usados apenas como metadados na documentação (ex.: Unnamed: 0, title, description, taster_twitter_handle).
• Conversão e limpeza de tipos: garantimos que price e points estejam em formato numérico; tratamos valores ausentes com imputações simples (mediana para numéricas; rótulo "Unknown" para categóricas).
• Criação do alvo (quando aplicável): a partir de points, derivamos a variável quality_high (1 se points ≥ 90; 0 caso contrário). Para evitar vazamento de informação, points não será usada como feature nos modelos supervisionados.
• Codificação de categóricas: para esta versão “base preparada” usada na documentação, aplicamos Label Encoding coluna a coluna (adequado para árvore; nas seções de treino do KNN/K-Means faremos scaling e codificações apropriadas nos pipelines).
• Entrega de uma visão pronta para modelagem: apresentamos uma amostra da base já limpa e codificada, com quality_high disponível para as etapas supervisionadas e os demais campos prontos para uso em pipelines.

import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder

# ===== 1) Ler base =====
df = pd.read_csv("./src/wine.csv")

# ===== 2) Remover colunas irrelevantes (se existirem) =====
drop_cols = ["Unnamed: 0", "title", "description", "taster_twitter_handle"]
df = df.drop(columns=[c for c in drop_cols if c in df.columns], errors="ignore")

# ===== 3) Garantir tipos numéricos e tratar nulos =====
if "points" in df.columns:
    df["points"] = pd.to_numeric(df["points"], errors="coerce")
if "price" in df.columns:
    df["price"] = pd.to_numeric(df["price"], errors="coerce")

num_cols = df.select_dtypes(include=["number"]).columns.tolist()
cat_cols = df.select_dtypes(exclude=["number"]).columns.tolist()

for c in num_cols:
    med = df[c].median() if df[c].notna().any() else 0
    df[c] = df[c].fillna(med)

for c in cat_cols:
    df[c] = df[c].fillna("Unknown")

# ===== 4) Criar alvo supervisionado (se houver points) =====
if "points" in df.columns:
    df["quality_high"] = (df["points"] >= 90).astype(int)

# ===== 5) Codificação simples de categóricas (rastreável) =====
df_ready = df.copy()
for c in df_ready.select_dtypes(exclude=["number"]).columns:
    le = LabelEncoder()
    df_ready[c] = le.fit_transform(df_ready[c].astype(str))

# ===== 6) Evitar vazamento: retirar 'points' das features "base" =====
if "points" in df_ready.columns:
    df_ready = df_ready.drop(columns=["points"])

# ===== 7) Mostrar SOMENTE algumas linhas para não poluir o markdown =====
n_show = min(20, len(df_ready))
print(f"Dimensão (após pré-processamento): {df_ready.shape[0]} linhas x {df_ready.shape[1]} colunas\n")
print(df_ready.sample(n=n_show, random_state=42).to_markdown(index=False))

Divisão dos Dados

Com a base pré-processada, realizou-se a divisão entre conjuntos de treinamento e teste.
O objetivo dessa etapa é garantir que o modelo seja avaliado em dados que ele nunca viu durante o treinamento, permitindo uma medida mais confiável de sua capacidade de generalização.

Foi utilizada a função train_test_split da biblioteca scikit-learn, com os seguintes critérios:
- 70% dos dados destinados ao treinamento, para que o modelo aprenda os padrões da base;
- 30% dos dados destinados ao teste, para avaliar o desempenho em novos exemplos;
- Estratificação pelo alvo (quality_high), garantindo que a proporção entre classes seja mantida em ambos os conjuntos;
- Random State fixado, assegurando reprodutibilidade na divisão.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder

# ===== 1) Ler base =====
df = pd.read_csv("./src/wine.csv")

# ===== 2) Remover colunas irrelevantes (se existirem) =====
drop_cols = ["Unnamed: 0", "title", "description", "taster_twitter_handle"]
df = df.drop(columns=[c for c in drop_cols if c in df.columns], errors="ignore")

# ===== 3) Conversões de tipo essenciais =====
if "points" in df.columns:
    df["points"] = pd.to_numeric(df["points"], errors="coerce")
if "price" in df.columns:
    df["price"] = pd.to_numeric(df["price"], errors="coerce")

# ===== 4) Criar alvo supervisionado a partir de 'points' =====
# quality_high = 1 (>= 90), 0 (< 90)
# Linhas sem 'points' não ajudam na classificação — removemos
df = df[df["points"].notna()].copy()
df["quality_high"] = (df["points"] >= 90).astype(int)

# ===== 5) Codificar variáveis categóricas (LabelEncoder simples) =====
cat_cols = [
    col for col in ["country", "province", "region_1", "region_2",
                    "taster_name", "designation", "variety", "winery"]
    if col in df.columns
]

for c in cat_cols:
    le = LabelEncoder()
    df[c] = df[c].fillna("Unknown").astype(str)
    df[c] = le.fit_transform(df[c])

# ===== 6) Definir X (features) e y (alvo), evitando vazamento de 'points' =====
feature_cols = []
feature_cols += [c for c in cat_cols]              # categóricas codificadas
if "price" in df.columns:
    feature_cols.append("price")                   # numérica útil
# NÃO usar 'points' como feature (origem do alvo)
X = df[feature_cols].copy()
y = df["quality_high"].copy()

# ===== 7) Divisão treino/teste com estratificação =====
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.30,
    random_state=27,
    stratify=y
)

Treinamento do Modelo — Árvore de Decisão

Nesta etapa treinamos um DecisionTreeClassifier utilizando a base pré-processada.
Mantemos a mesma preparação usada na divisão (remoção de colunas irrelevantes, criação de quality_high a partir de points, codificação das categóricas) e realizamos o ajuste do modelo com 70/30 de treino/teste e random_state=27.