Decision Tree

df = pd.read_csv("Global_Tech_Gadget_Consumption.csv")

df.head()

df.info()

display(df.describe())

print(df.isnull().sum())
df = df.drop_duplicates()

# Gráfico 1: Evolução do gasto médio por país ao longo dos anos
plt.figure(figsize=(12,6))
sns.lineplot(data=df, x="Year", y="Average Consumer Spending on Gadgets ($)", hue="Country", marker="o")
plt.title("Evolução do Gasto Médio em Gadgets por País (ao longo dos anos)")
plt.ylabel("Gasto Médio (US$)")
plt.xlabel("Ano")
plt.legend(title="País")
plt.show()

# Gráfico 2: Evolução do e-waste gerado por país ao longo dos anos
plt.figure(figsize=(12,6))
sns.lineplot(data=df, x="Year", y="E-Waste Generated (Metric Tons)", hue="Country", marker="o")
plt.title("Evolução do Lixo Eletrônico Gerado por País (ao longo dos anos)")
plt.ylabel("E-Waste (Toneladas Métricas)")
plt.xlabel("Ano")
plt.legend(title="País")
plt.show()

# Agrupar por país: calcular média de gasto médio e e-waste
rank_df = df.groupby("Country")[["Average Consumer Spending on Gadgets ($)", "E-Waste Generated (Metric Tons)"]].mean()

# Criar rankings: maior gasto = rank 1, maior e-waste = rank 1
rank_df["Rank_Gasto"] = rank_df["Average Consumer Spending on Gadgets ($)"].rank(method="dense", ascending=False)
rank_df["Rank_Ewaste"] = rank_df["E-Waste Generated (Metric Tons)"].rank(method="dense", ascending=False)

# Diferença absoluta entre rankings
rank_df["Diferença_Rank"] = abs(rank_df["Rank_Gasto"] - rank_df["Rank_Ewaste"])

# Ordenar: países com ciclos mais parecidos primeiro
rank_df_sorted = rank_df.sort_values("Diferença_Rank")

# Exibir tabela
print(rank_df_sorted)

# → Entender a forma da distribuição
# (normal, enviesada, multimodal)

num_cols = [
    "Smartphone Sales (Millions)",
    "Laptop Shipments (Millions)",
    "Gaming Console Adoption (%)",
    "Smartwatch Penetration (%)",
    "5G Penetration Rate (%)",
    "Average Consumer Spending on Gadgets ($)",
    "E-Waste Generated (Metric Tons)"
]

plt.figure(figsize=(15, 12))
for i, col in enumerate(num_cols, 1):
    plt.subplot(3, 3, i)
    sns.histplot(df[col], kde=True, bins=20, color="steelblue")
    plt.title(f"Distribuição de {col}")
plt.tight_layout()
plt.show()

# → Detectar possíveis outliers univariados.
plt.figure(figsize=(15, 10))
for i, col in enumerate(num_cols, 1):
    plt.subplot(3, 3, i)
    sns.boxplot(x=df[col], color="lightcoral")
    plt.title(f"Boxplot de {col}")
plt.tight_layout()
plt.show()

# → Ver clusters/agrupamentos e outliers
# considerando 2 variáveis ao mesmo tempo.
sns.pairplot(df[num_cols], diag_kind="kde")
plt.suptitle("Matriz de Dispersão (Scatterplots)", y=1.02)
plt.show()

# Para observar equilíbrio de classes
print(y.value_counts(dropna=False))
# Split, treino, avaliação
x_train, x_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

classifier = tree.DecisionTreeClassifier(random_state=42, class_weight="balanced")  # segue o estilo "padrão"
classifier.fit(x_train, y_train)

accuracy = classifier.score(x_test, y_test)
print(f"Accurácia: {accuracy:.2f}")

# Previsões para usar depois em relatório/matriz
y_pred = classifier.predict(x_test)

plt.figure(figsize=(12, 10))
tree.plot_tree(
    classifier,
    feature_names=X.columns.tolist(),
    class_names=["Sujo", "Verde"],
    filled=True
)

# Matriz de confusão
print(classification_report(y_test, y_pred, target_names=["Sujo","Verde"]))
print(confusion_matrix(y_test, y_pred, labels=[0,1]))

#PLOTAR

# Baseline
print("Distribuição de classes:")
print(y.value_counts().rename({0: "Sujo", 1: "Verde"}))
print("\nProporção (%):")
print((y.value_counts(normalize=True)*100).round(2).rename({0: "Sujo", 1: "Verde"}))

(y.value_counts(normalize=True)*100).plot(
    kind="bar", color=["#ff9999","#66b3ff"], figsize=(5,4)
)
plt.xticks([0,1], ["Sujo","Verde"])
plt.xlabel("Crescimento")
plt.ylabel("Percentual (%)")
plt.title("Target")
plt.show()

# ============================================
# PREPROCESS COM NOVA LÓGICA
# ============================================

def preprocess(df):
    # 1) Ordenar por País e Ano
    df = df.sort_values(["Country", "Year"]).copy()

    # 2) Codificar país
    le = LabelEncoder()
    df["Country_Code"] = le.fit_transform(df["Country"])

    # 3) Deltas ano a ano por país
    df["Delta_Spending"] = df.groupby("Country")["Average Consumer Spending on Gadgets ($)"].diff()
    df["Delta_Ewaste"]   = df.groupby("Country")["E-Waste Generated (Metric Tons)"].diff()

    # 4) Classe alvo (NOVA REGRA):
    #    1 = Verde  se ΔSpending > 0 e ΔEwaste > 0
    #    0 = Sujo   se ΔSpending > 0 e ΔEwaste ≤ 0
    #    anos com ΔSpending ≤ 0 ficam sem rótulo
    def classify_growth(row):
        if pd.notnull(row["Delta_Spending"]) and row["Delta_Spending"] > 0:
            return 1 if row["Delta_Ewaste"] > 0 else 0
        return None

    df["Sustentabilidade"] = df.apply(classify_growth, axis=1)
    df = df.dropna(subset=["Sustentabilidade"]).copy()
    df["Sustentabilidade"] = df["Sustentabilidade"].astype(int)

    # 5) Seleção de features
    features = [
        "Smartphone Sales (Millions)",
        "Laptop Shipments (Millions)",
        "Gaming Console Adoption (%)",
        "Smartwatch Penetration (%)",
        "5G Penetration Rate (%)",
        "Country_Code",
        "Year"
    ]

    X = df[features].copy()
    y = df["Sustentabilidade"].copy()
    return X, y

# ============================================
# MODELO 2: Árvore de Decisão com Oversampling (SMOTE)
# ============================================
!pip install imbalanced-learn

from imblearn.over_sampling import SMOTE
from sklearn import tree
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, ConfusionMatrixDisplay
from sklearn.model_selection import train_test_split
from collections import Counter
import matplotlib.pyplot as plt

# 1) Rodar preprocess
X, y = preprocess(df)

# 2) Split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 3) Mostrar distribuição original
print("Distribuição original do treino:", Counter(y_train))

# 4) Aplicar SMOTE
sm = SMOTE(random_state=42)
X_train_res, y_train_res = sm.fit_resample(X_train, y_train)
print("Distribuição após SMOTE:", Counter(y_train_res))

# 5) Treinar classificador balanceado
classifier_smote = tree.DecisionTreeClassifier(random_state=42)
classifier_smote.fit(X_train_res, y_train_res)

# 6) Avaliar no conjunto de teste
y_pred_smote = classifier_smote.predict(X_test)

print(f"\nAcurácia (com SMOTE): {accuracy_score(y_test, y_pred_smote):.2f}")
print("\nRelatório de Classificação (SMOTE):")
print(classification_report(y_test, y_pred_smote, target_names=["Sujo","Verde"]))

# 7) Matriz de confusão
cm = confusion_matrix(y_test, y_pred_smote, labels=[0,1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Sujo","Verde"])
disp.plot(cmap="Blues", values_format="d")
plt.title("Matriz de Confusão - Modelo com SMOTE")
plt.show()

y_prob = classifier.predict_proba(x_test)[:,1]

print("AUC-ROC:", roc_auc_score(y_test, y_prob))

# Curva ROC
fpr, tpr, _ = roc_curve(y_test, y_prob)
plt.figure(figsize=(6,5))
plt.plot(fpr, tpr, label=f"AUC = {roc_auc_score(y_test, y_prob):.3f}")
plt.plot([0,1], [0,1], linestyle="--")
plt.xlabel("Falso Positivo (1 - Especificidade)")
plt.ylabel("Verdadeiro Positivo (Recall)")
plt.title("Curva ROC - Modelo Original")
plt.legend()
plt.show()

# Complexidade e interpretabilidade ---
print("\nProfundidade da árvore:", best_clf.get_depth())
print("Número de folhas:", best_clf.get_n_leaves())

print("Importâncias (features):")
for name, imp in sorted(zip(X.columns, best_clf.feature_importances_), key=lambda t: -t[1]):
    print(f"  {name}: {imp:.3f}")

# Curva ROC (mantém apenas visual de separação) ---
# (se ainda não tiver y_prob_best definido, descomente a linha abaixo)
# y_prob_best = best_clf.predict_proba(x_test)[:, 1]

from sklearn.metrics import roc_auc_score, roc_curve
import matplotlib.pyplot as plt

fpr, tpr, _ = roc_curve(y_test, y_prob_best)
plt.figure(figsize=(6,5))
plt.plot(fpr, tpr, label=f"AUC = {roc_auc_score(y_test, y_prob_best):.3f}")
plt.plot([0,1], [0,1], linestyle="--")
plt.xlabel("Falso Positivo (1 - Especificidade)")
plt.ylabel("Verdadeiro Positivo (Recall)")
plt.title("Curva ROC - Best Decision Tree (GridSearchCV)")
plt.legend()
plt.show()

# ============================================
# PREPROCESS (Verde se ΔSpending > 0 e ΔEwaste > 0)
# ============================================
import pandas as pd
from sklearn.preprocessing import LabelEncoder

def preprocess(df):
    # 1) Ordenar por País e Ano
    df = df.sort_values(["Country", "Year"]).copy()

    # 2) Codificar país
    le = LabelEncoder()
    df["Country_Code"] = le.fit_transform(df["Country"])

    # 3) Deltas ano a ano por país
    df["Delta_Spending"] = df.groupby("Country")["Average Consumer Spending on Gadgets ($)"].diff()
    df["Delta_Ewaste"]   = df.groupby("Country")["E-Waste Generated (Metric Tons)"].diff()

    # 4) Classe alvo (regra invertida):
    #    1 = Verde  se ΔSpending > 0 e ΔEwaste > 0
    #    0 = Sujo   se ΔSpending > 0 e ΔEwaste ≤ 0
    #    anos com ΔSpending ≤ 0 ficam sem rótulo
    def classify_growth(row):
        if pd.notnull(row["Delta_Spending"]) and row["Delta_Spending"] > 0:
            return 1 if row["Delta_Ewaste"] > 0 else 0
        return None

    df["Sustentabilidade"] = df.apply(classify_growth, axis=1)
    df = df.dropna(subset=["Sustentabilidade"]).copy()
    df["Sustentabilidade"] = df["Sustentabilidade"].astype(int)

    # 5) Features (SEM "Laptop Shipments (Millions)")
    features = [
        "Smartphone Sales (Millions)",
        "Gaming Console Adoption (%)",
        "Smartwatch Penetration (%)",
        "5G Penetration Rate (%)",
        "Country_Code",
        "Year"
    ]

    X = df[features].copy()
    y = df["Sustentabilidade"].copy()
    return X, y

# ============================================
# SPLIT TREINO/TESTE
# ============================================
from sklearn.model_selection import train_test_split

# df deve estar carregado previamente, ex.: df = pd.read_csv("Global_Tech_Gadget_Consumption.csv")
X, y = preprocess(df)

x_train, x_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# ============================================
# TUNING COM GRIDSEARCHCV (otimizando F1 da minoria = classe 1)
# ============================================
from sklearn import tree
from sklearn.model_selection import GridSearchCV, StratifiedKFold
from sklearn.metrics import (
    make_scorer, f1_score, accuracy_score, balanced_accuracy_score,
    roc_auc_score, classification_report, confusion_matrix, roc_curve
)
import matplotlib.pyplot as plt

# scorer F1 da classe minoritária (Verde = 1)
f1_minority = make_scorer(f1_score, pos_label=1)

param_grid = {
    "criterion": ["gini", "entropy"],
    "max_depth": [3, 4, 5, 7, None],
    "min_samples_split": [2, 5, 10],
    "min_samples_leaf": [1, 2, 5]
}

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
grid = GridSearchCV(
    estimator=tree.DecisionTreeClassifier(random_state=42),
    param_grid=param_grid,
    scoring=f1_minority,
    cv=cv,
    n_jobs=-1,
    refit=True,
    verbose=0
)

grid.fit(x_train, y_train)

print("=== MELHOR CONJUNTO (CV, F1 classe 1) ===")
print(grid.best_params_)

best_clf = grid.best_estimator_

# ============================================
# AVALIAÇÃO NO TESTE
# ============================================
y_pred_best = best_clf.predict(x_test)
y_prob_best = best_clf.predict_proba(x_test)[:, 1]

print("\n=== AVALIAÇÃO NO TESTE (Best Model) ===")
print("Accuracy:", accuracy_score(y_test, y_pred_best))
print("Balanced Accuracy:", balanced_accuracy_score(y_test, y_pred_best))
print("F1 (classe 1 - Verde):", f1_score(y_test, y_pred_best, pos_label=1))
print("F1 (macro):", f1_score(y_test, y_pred_best, average="macro"))
print("AUC-ROC:", roc_auc_score(y_test, y_prob_best))
print("\nRelatório de Classificação:\n", classification_report(y_test, y_pred_best, target_names=["Sujo","Verde"]))
print("Matriz de Confusão:\n", confusion_matrix(y_test, y_pred_best, labels=[0,1]))

# Complexidade e interpretabilidade
print("\nProfundidade da árvore:", best_clf.get_depth())
print("Número de folhas:", best_clf.get_n_leaves())
print("Importâncias (features):")
for name, imp in sorted(zip(X.columns, best_clf.feature_importances_), key=lambda t: -t[1]):
    print(f"  {name}: {imp:.3f}")

# ============================================
# CURVA ROC
# ============================================
fpr, tpr, _ = roc_curve(y_test, y_prob_best)
plt.figure(figsize=(6,5))
plt.plot(fpr, tpr, label=f"AUC = {roc_auc_score(y_test, y_prob_best):.3f}")
plt.plot([0,1], [0,1], linestyle="--")
plt.xlabel("Falso Positivo (1 - Especificidade)")
plt.ylabel("Verdadeiro Positivo (Recall)")
plt.title("Curva ROC - Best Decision Tree (GridSearchCV)")
plt.legend()
plt.show()

# ============================================
# PREPROCESS (Verde se ΔSpending > 0 e ΔEwaste > 0)
# ============================================
import pandas as pd
from sklearn.preprocessing import LabelEncoder

def preprocess(df):
    # 1) Ordenar por País e Ano
    df = df.sort_values(["Country", "Year"]).copy()

    # 2) Codificar país
    le = LabelEncoder()
    df["Country_Code"] = le.fit_transform(df["Country"])

    # 3) Deltas ano a ano por país
    df["Delta_Spending"] = df.groupby("Country")["Average Consumer Spending on Gadgets ($)"].diff()
    df["Delta_Ewaste"]   = df.groupby("Country")["E-Waste Generated (Metric Tons)"].diff()

    # 4) Classe alvo (regra invertida):
    #    1 = Verde  se ΔSpending > 0 e ΔEwaste > 0
    #    0 = Sujo   se ΔSpending > 0 e ΔEwaste <= 0
    #    anos com ΔSpending ≤ 0 ficam sem rótulo
    def classify_growth(row):
        if pd.notnull(row["Delta_Spending"]) and row["Delta_Spending"] > 0:
            return 1 if row["Delta_Ewaste"] > 0 else 0
        return None

    df["Sustentabilidade"] = df.apply(classify_growth, axis=1)
    df = df.dropna(subset=["Sustentabilidade"]).copy()
    df["Sustentabilidade"] = df["Sustentabilidade"].astype(int)

    # 5) Features (SEM "5G Penetration Rate (%)" e já sem "Laptop Shipments (Millions)")
    features = [
        "Smartphone Sales (Millions)",
        "Gaming Console Adoption (%)",
        "Smartwatch Penetration (%)",
        "Country_Code",
        "Year"
    ]

    X = df[features].copy()
    y = df["Sustentabilidade"].copy()
    return X, y

# ============================================
# SPLIT TREINO/TESTE
# ============================================
from sklearn.model_selection import train_test_split

# df deve estar carregado previamente
X, y = preprocess(df)

x_train, x_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# ============================================
# TUNING COM GRIDSEARCHCV (otimizando F1 da minoria = classe 1)
# ============================================
from sklearn import tree
from sklearn.model_selection import GridSearchCV, StratifiedKFold
from sklearn.metrics import (
    make_scorer, f1_score, accuracy_score, balanced_accuracy_score,
    roc_auc_score, classification_report, confusion_matrix, roc_curve
)
import matplotlib.pyplot as plt

# scorer F1 da classe minoritária (Verde = 1)
f1_minority = make_scorer(f1_score, pos_label=1)

param_grid = {
    "criterion": ["gini", "entropy"],
    "max_depth": [3, 4, 5, 7, None],
    "min_samples_split": [2, 5, 10],
    "min_samples_leaf": [1, 2, 5]
}

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
grid = GridSearchCV(
    estimator=tree.DecisionTreeClassifier(random_state=42),
    param_grid=param_grid,
    scoring=f1_minority,
    cv=cv,
    n_jobs=-1,
    refit=True,
    verbose=0
)

grid.fit(x_train, y_train)

print("=== MELHOR CONJUNTO (CV, F1 classe 1) ===")
print(grid.best_params_)

best_clf = grid.best_estimator_

# ============================================
# AVALIAÇÃO NO TESTE
# ============================================
y_pred_best = best_clf.predict(x_test)
y_prob_best = best_clf.predict_proba(x_test)[:, 1]

print("\n=== AVALIAÇÃO NO TESTE (Best Model) ===")
print("Accuracy:", accuracy_score(y_test, y_pred_best))
print("Balanced Accuracy:", balanced_accuracy_score(y_test, y_pred_best))
print("F1 (classe 1 - Verde):", f1_score(y_test, y_pred_best, pos_label=1))
print("F1 (macro):", f1_score(y_test, y_pred_best, average="macro"))
print("AUC-ROC:", roc_auc_score(y_test, y_prob_best))
print("\nRelatório de Classificação:\n", classification_report(y_test, y_pred_best, target_names=["Sujo","Verde"]))
print("Matriz de Confusão:\n", confusion_matrix(y_test, y_pred_best, labels=[0,1]))

# Complexidade e interpretabilidade
print("\nProfundidade da árvore:", best_clf.get_depth())
print("Número de folhas:", best_clf.get_n_leaves())
print("Importâncias (features):")
for name, imp in sorted(zip(X.columns, best_clf.feature_importances_), key=lambda t: -t[1]):
    print(f"  {name}: {imp:.3f}")

# ============================================
# CURVA ROC
# ============================================
fpr, tpr, _ = roc_curve(y_test, y_prob_best)
plt.figure(figsize=(6,5))
plt.plot(fpr, tpr, label=f"AUC = {roc_auc_score(y_test, y_prob_best):.3f}")
plt.plot([0,1], [0,1], linestyle="--")
plt.xlabel("Falso Positivo (1 - Especificidade)")
plt.ylabel("Verdadeiro Positivo (Recall)")
plt.title("Curva ROC - Best Decision Tree (GridSearchCV)")
plt.legend()
plt.show()

# ============================================
# PREPROCESS (Verde se ΔSpending > 0 e ΔEwaste > 0)
# ============================================
import pandas as pd
from sklearn.preprocessing import LabelEncoder

def preprocess(df):
    # 1) Ordenar por País e Ano
    df = df.sort_values(["Country", "Year"]).copy()

    # 2) Codificar país
    le = LabelEncoder()
    df["Country_Code"] = le.fit_transform(df["Country"])

    # 3) Deltas ano a ano por país
    df["Delta_Spending"] = df.groupby("Country")["Average Consumer Spending on Gadgets ($)"].diff()
    df["Delta_Ewaste"]   = df.groupby("Country")["E-Waste Generated (Metric Tons)"].diff()

    # 4) Classe alvo (regra invertida):
    #    1 = Verde  se ΔSpending > 0 e ΔEwaste > 0
    #    0 = Sujo   se ΔSpending > 0 e ΔEwaste <= 0
    def classify_growth(row):
        if pd.notnull(row["Delta_Spending"]) and row["Delta_Spending"] > 0:
            return 1 if row["Delta_Ewaste"] > 0 else 0
        return None

    df["Sustentabilidade"] = df.apply(classify_growth, axis=1)
    df = df.dropna(subset=["Sustentabilidade"]).copy()
    df["Sustentabilidade"] = df["Sustentabilidade"].astype(int)

    # 5) Features (apenas Smartphones + País + Ano)
    features = [
        "Smartphone Sales (Millions)",
        "Country_Code",
        "Year"
    ]

    X = df[features].copy()
    y = df["Sustentabilidade"].copy()
    return X, y

# ============================================
# SPLIT TREINO/TESTE
# ============================================
from sklearn.model_selection import train_test_split

# df deve estar carregado previamente
X, y = preprocess(df)

x_train, x_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# ============================================
# TUNING COM GRIDSEARCHCV (otimizando F1 da minoria = classe 1)
# ============================================
from sklearn import tree
from sklearn.model_selection import GridSearchCV, StratifiedKFold
from sklearn.metrics import (
    make_scorer, f1_score, accuracy_score, balanced_accuracy_score,
    roc_auc_score, classification_report, confusion_matrix, roc_curve
)
import matplotlib.pyplot as plt

# scorer F1 da classe minoritária (Verde = 1)
f1_minority = make_scorer(f1_score, pos_label=1)

param_grid = {
    "criterion": ["gini", "entropy"],
    "max_depth": [3, 4, 5, 7, None],
    "min_samples_split": [2, 5, 10],
    "min_samples_leaf": [1, 2, 5]
}

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
grid = GridSearchCV(
    estimator=tree.DecisionTreeClassifier(random_state=42),
    param_grid=param_grid,
    scoring=f1_minority,
    cv=cv,
    n_jobs=-1,
    refit=True,
    verbose=0
)

grid.fit(x_train, y_train)

print("=== MELHOR CONJUNTO (CV, F1 classe 1) ===")
print(grid.best_params_)

best_clf = grid.best_estimator_

# ============================================
# AVALIAÇÃO NO TESTE
# ============================================
y_pred_best = best_clf.predict(x_test)
y_prob_best = best_clf.predict_proba(x_test)[:, 1]

print("\n=== AVALIAÇÃO NO TESTE (Best Model) ===")
print("Accuracy:", accuracy_score(y_test, y_pred_best))
print("Balanced Accuracy:", balanced_accuracy_score(y_test, y_pred_best))
print("F1 (classe 1 - Verde):", f1_score(y_test, y_pred_best, pos_label=1))
print("F1 (macro):", f1_score(y_test, y_pred_best, average="macro"))
print("AUC-ROC:", roc_auc_score(y_test, y_prob_best))
print("\nRelatório de Classificação:\n", classification_report(y_test, y_pred_best, target_names=["Sujo","Verde"]))
print("Matriz de Confusão:\n", confusion_matrix(y_test, y_pred_best, labels=[0,1]))

# Complexidade e interpretabilidade
print("\nProfundidade da árvore:", best_clf.get_depth())
print("Número de folhas:", best_clf.get_n_leaves())
print("Importâncias (features):")
for name, imp in sorted(zip(X.columns, best_clf.feature_importances_), key=lambda t: -t[1]):
    print(f"  {name}: {imp:.3f}")

# ============================================
# CURVA ROC
# ============================================
fpr, tpr, _ = roc_curve(y_test, y_prob_best)
plt.figure(figsize=(6,5))
plt.plot(fpr, tpr, label=f"AUC = {roc_auc_score(y_test, y_prob_best):.3f}")
plt.plot([0,1], [0,1], linestyle="--")
plt.xlabel("Falso Positivo (1 - Especificidade)")
plt.ylabel("Verdadeiro Positivo (Recall)")
plt.title("Curva ROC - Best Decision Tree (GridSearchCV)")
plt.legend()
plt.show()

# Criação de um novo dataframe para plot das informações de classificação quanto a sustentabilidade

# Parte 1) copiar e garantir ordenação
df_sustentability = df.sort_values(["Country", "Year"]).copy()

# Parte 2) codificar Country (opcional, se precisar do código do país)
le = LabelEncoder()
df_sustentability["Country_Code"] = le.fit_transform(df_sustentability["Country"])

# Parte 3) deltas por país (mesma lógica do preprocess)
df_sustentability["Delta_Spending"] = df_sustentability.groupby("Country")["Average Consumer Spending on Gadgets ($)"].diff()
df_sustentability["Delta_Ewaste"]   = df_sustentability.groupby("Country")["E-Waste Generated (Metric Tons)"].diff()

# Parte 4) classe Sustentabilidade (igual ao seu target)
def classify_growth(row):
    if pd.notnull(row["Delta_Spending"]) and row["Delta_Spending"] > 0:
        return 1 if row["Delta_Ewaste"] <= 0 else 0
    return None

df_sustentability["Sustentabilidade"] = df_sustentability.apply(classify_growth, axis=1)
df_sustentability = df_sustentability.dropna(subset=["Sustentabilidade"]).copy()
df_sustentability["Sustentabilidade"] = df_sustentability["Sustentabilidade"].astype(int)
df_sustentability = df_sustentability.set_index("Year")


print(df_sustentability.head())

# Determinação se o perfil país em maior crescimento predominante sujo ou verde
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.preprocessing import LabelEncoder

# -----------------------------
# 1) Recalcular Sustentabilidade no mesmo padrão do modelo (sem Laptop Shipments)
# -----------------------------
df_tmp = df.sort_values(["Country","Year"]).copy()

# codificação país
le = LabelEncoder()
df_tmp["Country_Code"] = le.fit_transform(df_tmp["Country"])

# deltas
df_tmp["Delta_Spending"] = df_tmp.groupby("Country")["Average Consumer Spending on Gadgets ($)"].diff()
df_tmp["Delta_Ewaste"]   = df_tmp.groupby("Country")["E-Waste Generated (Metric Tons)"].diff()

def classify_growth(row):
    if pd.notnull(row["Delta_Spending"]) and row["Delta_Spending"] > 0:
        return 1 if row["Delta_Ewaste"] > 0 else 0  # Verde=1, Sujo=0
    return None

df_tmp["Sustentabilidade"] = df_tmp.apply(classify_growth, axis=1)
df_tmp = df_tmp.dropna(subset=["Sustentabilidade"]).copy()
df_tmp["Sustentabilidade"] = df_tmp["Sustentabilidade"].astype(int)

# -----------------------------
# 2) Resumo por país
# -----------------------------
ct = df_tmp.groupby(["Country","Sustentabilidade"]).size().unstack(fill_value=0)
ct = ct.rename(columns={0:"Sujo", 1:"Verde"})
prop = df_tmp.groupby("Country")["Sustentabilidade"].mean().to_frame("prop_verde")
summary = ct.join(prop)

def predom(row):
    if row["Verde"] > row["Sujo"]:
        return "Predominante Verde"
    elif row["Sujo"] > row["Verde"]:
        return "Predominante Sujo"
    else:
        return "Empate"

summary["Predominancia"] = summary.apply(predom, axis=1)
summary = summary.sort_values("prop_verde", ascending=False)

print("Resumo por país (contagem, proporção de Verde e predominância):")
display(summary)

# -----------------------------
# 3) Plots
# -----------------------------

# Heatmap proporção Verde
plt.figure(figsize=(8, max(4, 0.5*len(summary))))
sns.heatmap(summary[["prop_verde"]], annot=True, fmt=".2f", cmap="Greens", cbar_kws={"label":"Proporção Verde"})
plt.title("Proporção de Crescimento Verde por País")
plt.xlabel("")
plt.ylabel("País")
plt.show()

# Barras ordenadas por proporção (agrupadas por predominância)
palette = {
    "Predominante Verde": "#2ca02c",
    "Predominante Sujo": "#d62728",
    "Empate": "#7f7f7f"
}

plt.figure(figsize=(10, max(4, 0.5*len(summary))))
sns.barplot(
    data=summary.reset_index(),
    x="prop_verde", y="Country",
    hue="Predominancia", dodge=False, palette=palette, order=summary.reset_index()["Country"]
)
plt.xlim(0,1)
plt.xlabel("Proporção de Verde (0 a 1)")
plt.ylabel("País")
plt.title("Perfis por País: Predominância Sujo vs Verde (sem Laptop Shipments)")
plt.legend(title="Agrupamento")
plt.tight_layout()
plt.show()

# Barras empilhadas Sujo x Verde por país
stack_df = summary[["Sujo","Verde"]].reset_index().melt(id_vars="Country", var_name="Classe", value_name="count")
plt.figure(figsize=(10, max(4, 0.5*len(summary))))
sns.barplot(data=stack_df, x="count", y="Country", hue="Classe", hue_order=["Sujo","Verde"], order=summary.index)
plt.title("Cresciimento Sujo vs Verde por País (10 anos agregados)")
plt.xlabel("Número de casos")
plt.ylabel("País")
plt.tight_layout()
plt.show()

# Assuming df is already loaded and preprocess function is defined in a previous cell

# Preprocess the data and split into training and testing sets
X, y = preprocess(df)
x_train, x_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)


# pipeline: padroniza features e aplica KNN
pipe_knn = Pipeline(steps=[
    ("scaler", StandardScaler()),
    ("knn", KNeighborsClassifier())
])

# busca de hiperparâmetros (foco em F1 da minoria = classe 1)
param_grid_knn = {
    "knn__n_neighbors": [3, 5, 7, 9, 11],
    "knn__weights": ["uniform", "distance"],
    "knn__p": [1, 2],                      # 1=Manhattan, 2=Euclidiana
    "knn__leaf_size": [15, 30, 45]
}

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
f1_minority = make_scorer(f1_score, pos_label=1)

grid_knn = GridSearchCV(
    estimator=pipe_knn,
    param_grid=param_grid_knn,
    scoring=f1_minority,
    cv=cv,
    n_jobs=-1,
    refit=True,
    verbose=0
)

grid_knn.fit(x_train, y_train)

print("=== KNN: Melhor conjunto (CV, F1 classe 1) ===")
print(grid_knn.best_params_)

best_knn = grid_knn.best_estimator_

# -------- Avaliação no TESTE --------
y_pred_knn = best_knn.predict(x_test)
y_prob_knn = best_knn.predict_proba(x_test)[:, 1]

print("\n=== KNN | Avaliação no TESTE ===")
print("Accuracy:", accuracy_score(y_test, y_pred_knn))
print("Balanced Accuracy:", balanced_accuracy_score(y_test, y_pred_knn))
print("F1 (classe 1 - Verde):", f1_score(y_test, y_pred_knn, pos_label=1))
print("F1 (macro):", f1_score(y_test, y_pred_knn, average="macro"))
print("AUC-ROC:", roc_auc_score(y_test, y_prob_knn))
print("\nRelatório de Classificação:\n", classification_report(y_test, y_pred_knn, target_names=["Sujo","Verde"]))
print("Matriz de Confusão:\n", confusion_matrix(y_test, y_pred_knn, labels=[0,1]))

# Curva ROC do KNN
fpr, tpr, _ = roc_curve(y_test, y_prob_knn)
plt.figure(figsize=(6,5))
plt.plot(fpr, tpr, label=f"KNN AUC = {roc_auc_score(y_test, y_prob_knn):.3f}")
plt.plot([0,1], [0,1], linestyle="--")
plt.xlabel("Falso Positivo (1 - Especificidade)")
plt.ylabel("Verdadeiro Positivo (Recall)")
plt.title("Curva ROC - KNN (com StandardScaler)")
plt.legend()
plt.show()

print(grid_knn.best_params_)