Exercise 1 — Data

"""Exercise 1 - Point clouds: geometry and spread in 2D.

Gera as quatro nuvens gaussianas, mede a razao de separacao e a taxa de mistura
para cada fator de escala, e salva as Figuras 1, 1b, 2 e 3 em ../figures/.

Uso:  python ex1_point_clouds.py
"""

import os

import numpy as np
import pandas as pd
import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt

# Semente unica do relatorio.
rng = np.random.default_rng(42)

FIG_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "figures")
os.makedirs(FIG_DIR, exist_ok=True)

NAMES = ["Class 0", "Class 1", "Class 2", "Class 3"]
MEAN = np.array([[2, 3], [5, 6], [8, 1], [15, 4]], dtype=float)
STD = np.array([[0.8, 2.5], [1.2, 1.9], [0.9, 0.9], [0.5, 2.0]], dtype=float)
N = 100
SCALES = [0.5, 1.0, 2.0, 4.0]

# Ruido padrao sorteado uma unica vez e reaproveitado em todas as escalas, para
# que os paineis da Figura 2 mostrem as mesmas nuvens dilatando.
Z = rng.normal(0, 1, size=(len(MEAN), N, 2))


def generate_clouds(mean, std, z, scale=1.0):
    """As medias ficam fixas; todo desvio e multiplicado por `scale`."""
    X = mean[:, None, :] + (std * scale)[:, None, :] * z
    return X.reshape(-1, 2), np.repeat(np.arange(len(mean)), z.shape[1])


def separation_table(mean, std):
    """r_ij = ||mu_i - mu_j|| / (sigma_bar_i + sigma_bar_j)."""
    sigma_bar = std.mean(axis=1)
    linhas = []
    for i in range(len(mean)):
        for j in range(i + 1, len(mean)):
            dist = np.linalg.norm(mean[i] - mean[j])
            denom = sigma_bar[i] + sigma_bar[j]
            linhas.append(
                {
                    "pair": f"({i}, {j})",
                    "||mu_i - mu_j||": dist,
                    "sigma_bar_i + sigma_bar_j": denom,
                    "r_ij (s=1)": dist / denom,
                }
            )
    return pd.DataFrame(linhas).sort_values("r_ij (s=1)").reset_index(drop=True)


def mixing_rate(X, y, means):
    """Fracao de pontos cujo centro mais proximo nao e o da propria classe."""
    dists = np.linalg.norm(X[:, None, :] - means[None, :, :], axis=2)
    return float(np.mean(dists.argmin(axis=1) != y))


def figure_1(X, y, path):
    plt.figure(figsize=(8, 6))
    for c in range(len(NAMES)):
        m = y == c
        plt.scatter(X[m, 0], X[m, 1], s=14, alpha=0.7, label=NAMES[c])
    plt.scatter(MEAN[:, 0], MEAN[:, 1], marker="X", s=180, c="black",
                zorder=5, label="Class means")
    plt.title("Figure 1 - Four Gaussian clouds ($s = 1$)")
    plt.xlabel("$x_1$")
    plt.ylabel("$x_2$")
    plt.legend(loc="upper left", fontsize=9)
    plt.tight_layout()
    plt.savefig(path, dpi=130, bbox_inches="tight")
    plt.close()


def figure_2(datasets, path):
    all_pts = np.vstack([X for X, _ in datasets.values()])
    xlim = (all_pts[:, 0].min() - 1, all_pts[:, 0].max() + 1)
    ylim = (all_pts[:, 1].min() - 1, all_pts[:, 1].max() + 1)

    fig, axes = plt.subplots(2, 2, figsize=(12, 9))
    for ax, sc in zip(axes.flat, SCALES):
        X, y = datasets[sc]
        for c in range(len(NAMES)):
            m = y == c
            ax.scatter(X[m, 0], X[m, 1], s=10, alpha=0.6, label=NAMES[c])
        ax.scatter(MEAN[:, 0], MEAN[:, 1], marker="X", s=110, c="black",
                   zorder=5, label="Class means")
        ax.set_title(f"$s = {sc}$")
        ax.set_xlim(xlim)
        ax.set_ylim(ylim)
        ax.set_xlabel("$x_1$")
        ax.set_ylabel("$x_2$")
        ax.legend(loc="upper left", fontsize=8)
    fig.suptitle("Figure 2 - Same means, growing spread (shared axes)",
                 fontsize=15, fontweight="bold")
    plt.tight_layout()
    plt.savefig(path, dpi=130, bbox_inches="tight")
    plt.close()


def figure_3(mixing, r_min, path):
    fig, ax = plt.subplots(figsize=(8, 5))
    ax.plot(list(mixing.keys()), list(mixing.values()), marker="o",
            linewidth=2, markersize=9, label="mixing rate")
    for sc, v in mixing.items():
        ax.annotate(f"{v:.4f}", (sc, v), textcoords="offset points",
                    xytext=(0, 11), ha="center", fontsize=10)

    ax2 = ax.twinx()
    s_grid = np.linspace(min(SCALES), max(SCALES), 200)
    ax2.plot(s_grid, r_min / s_grid, linestyle="--", color="firebrick",
             linewidth=1.8, label="$r_{min}(s) = r_{min}(1)/s$")
    ax2.axhline(1.0, color="grey", linestyle=":", linewidth=1.2)
    ax2.set_ylabel("$r_{min}$", color="firebrick")
    ax2.grid(False)

    ax.set_title("Figure 3 - Mixing rate vs. scale factor")
    ax.set_xlabel("scale factor $s$")
    ax.set_ylabel("mixing rate")
    handles = ax.get_lines() + ax2.get_lines()[:1]
    ax.legend(handles, [h.get_label() for h in handles], loc="upper left", fontsize=9)
    plt.tight_layout()
    plt.savefig(path, dpi=130, bbox_inches="tight")
    plt.close()


def figure_1b(X, y, path):
    """Particao por centro mais proximo: esboco das fronteiras do item C.2."""
    xx, yy = np.meshgrid(
        np.linspace(X[:, 0].min() - 1, X[:, 0].max() + 1, 500),
        np.linspace(X[:, 1].min() - 1, X[:, 1].max() + 1, 500),
    )
    grid = np.c_[xx.ravel(), yy.ravel()]
    zz = np.linalg.norm(grid[:, None, :] - MEAN[None, :, :], axis=2).argmin(axis=1)
    zz = zz.reshape(xx.shape)

    plt.figure(figsize=(9, 6.5))
    plt.contourf(xx, yy, zz, levels=np.arange(-0.5, len(MEAN)), alpha=0.15)
    plt.contour(xx, yy, zz, levels=np.arange(-0.5, len(MEAN)),
                colors="black", linewidths=1.2, linestyles="--")
    for c in range(len(NAMES)):
        m = y == c
        plt.scatter(X[m, 0], X[m, 1], s=14, alpha=0.75, label=NAMES[c])
    plt.scatter(MEAN[:, 0], MEAN[:, 1], marker="X", s=170, c="black",
                zorder=5, label="Class means")
    plt.title("Figure 1b - Sketch of the decision boundaries")
    plt.xlabel("$x_1$")
    plt.ylabel("$x_2$")
    plt.legend(loc="upper left", fontsize=9)
    plt.tight_layout()
    plt.savefig(path, dpi=130, bbox_inches="tight")
    plt.close()


def main():
    X1, y1 = generate_clouds(MEAN, STD, Z, scale=1.0)
    print("A - Figure 1")
    print(f"  X {X1.shape} | pontos por classe {np.bincount(y1)}")
    figure_1(X1, y1, os.path.join(FIG_DIR, "fig1.png"))

    datasets = {sc: generate_clouds(MEAN, STD, Z, scale=sc) for sc in SCALES}
    figure_2(datasets, os.path.join(FIG_DIR, "fig2.png"))

    print("\nB.2 - Separation ratio (s = 1)")
    sep = separation_table(MEAN, STD)
    print(sep.round(4).to_string(index=False))
    par_min = sep.iloc[0]["pair"]
    r_min = float(sep.iloc[0]["r_ij (s=1)"])
    print(f"  menor r_ij: {r_min:.4f} no par {par_min}")
    print(f"  em s = 2 (extrapolado): {r_min / 2:.4f}")

    print("\nB.3 - Mixing rate")
    mixing = {sc: mixing_rate(X, y, MEAN) for sc, (X, y) in datasets.items()}
    for sc in SCALES:
        print(f"  s = {sc:<4} mixing {mixing[sc]:.4f}   r_min(s) = {r_min / sc:.4f}")
    figure_3(mixing, r_min, os.path.join(FIG_DIR, "fig3.png"))

    print("\nC.2 - Figure 1b")
    figure_1b(X1, y1, os.path.join(FIG_DIR, "fig1b.png"))

    print("\nFiguras salvas em", os.path.normpath(FIG_DIR))


if __name__ == "__main__":
    main()

"""Exercise 2 - Non-linearity in higher dimensions.

Gera o Dataset I (gaussianas 5D deslocadas) e o Dataset II (cascas concentricas),
aplica PCA, mede distancia entre centros e raios, e salva as Figuras 4 e 5.

Uso:  python ex2_nonlinearity.py
"""

import os

import numpy as np
import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA

rng = np.random.default_rng(42)

FIG_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "figures")
os.makedirs(FIG_DIR, exist_ok=True)

DIM = 5
N_5D = 500

MEAN_A = np.array([0.0, 0.0, 0.0, 0.0, 0.0])
MEAN_B = np.array([1.5, 1.5, 1.5, 1.5, 1.5])

# Sigma_A: correlacao positiva entre as features 0 e 1.
COV_A = np.array([
    [1.0, 0.8, 0.1, 0.0, 0.0],
    [0.8, 1.0, 0.3, 0.0, 0.0],
    [0.1, 0.3, 1.0, 0.5, 0.0],
    [0.0, 0.0, 0.5, 1.0, 0.2],
    [0.0, 0.0, 0.0, 0.2, 1.0],
])

# Sigma_B: variancias maiores e correlacao negativa entre as features 0 e 1.
COV_B = np.array([
    [1.5, -0.7, 0.2, 0.0, 0.0],
    [-0.7, 1.5, 0.4, 0.0, 0.0],
    [0.2, 0.4, 1.5, 0.6, 0.0],
    [0.0, 0.0, 0.6, 1.5, 0.3],
    [0.0, 0.0, 0.0, 0.3, 1.5],
])

RADIUS_C = {"mu": 2.0, "sigma": 0.4}
RADIUS_D = {"mu": 5.0, "sigma": 0.4}


def sample_shell(n, dim, mu_r, sigma_r):
    """Direcao uniforme na esfera unitaria, raio ~ Normal(mu_r, sigma_r)."""
    directions = rng.normal(0, 1, size=(n, dim))
    directions /= np.linalg.norm(directions, axis=1, keepdims=True)
    radii = np.clip(rng.normal(mu_r, sigma_r, n), 0, None)
    return directions * radii[:, None]


def centre_distance(X, y):
    """Distancia euclidiana entre os dois centroides, no espaco 5D original."""
    return float(np.linalg.norm(X[y == 0].mean(axis=0) - X[y == 1].mean(axis=0)))


def separate_dataset_ii(X, tau):
    """g(x) = sum(x_i^2) - tau^2; retorna 1 (casca) se g(x) > 0, senao 0."""
    return (np.sum(X ** 2, axis=1) > tau ** 2).astype(int)


def figure_4(P1, y1, evr1, P2, y2, evr2, path):
    fig, axes = plt.subplots(1, 2, figsize=(13, 5.5))
    painels = [
        (axes[0], P1, y1, ("Class A", "Class B"),
         "Dataset I - shifted Gaussians", evr1),
        (axes[1], P2, y2, ("Class C (core)", "Class D (shell)"),
         "Dataset II - concentric shells", evr2),
    ]
    for ax, P, y, nomes, titulo, evr in painels:
        for k, nome in enumerate(nomes):
            m = y == k
            ax.scatter(P[m, 0], P[m, 1], s=14, alpha=0.55, label=nome)
        ax.set_title(f"{titulo}\nPC1+PC2 = {evr.sum():.1%} da variancia")
        ax.set_xlabel(f"PC1 ({evr[0]:.1%})")
        ax.set_ylabel(f"PC2 ({evr[1]:.1%})")
        ax.legend(fontsize=9)
        ax.set_aspect("equal", adjustable="datalim")
    fig.suptitle("Figure 4 - PCA projection of both 5D datasets",
                 fontsize=15, fontweight="bold")
    plt.tight_layout()
    plt.savefig(path, dpi=130, bbox_inches="tight")
    plt.close()


def figure_5(r_ds1, r_ds2, path):
    fig, axes = plt.subplots(1, 2, figsize=(13, 5))
    for ax, radii, titulo in [(axes[0], r_ds1, "Dataset I"),
                              (axes[1], r_ds2, "Dataset II")]:
        for nome, r in radii.items():
            ax.hist(r, bins=40, alpha=0.6, edgecolor="white",
                    label=f"{nome} (mean {r.mean():.2f})")
        ax.set_title(f"{titulo} - radius $\\|x\\|$")
        ax.set_xlabel("$\\|x\\|$")
        ax.set_ylabel("count")
        ax.legend(fontsize=9)
    fig.suptitle("Figure 5 - Radius histogram, both classes overlaid",
                 fontsize=15, fontweight="bold")
    plt.tight_layout()
    plt.savefig(path, dpi=130, bbox_inches="tight")
    plt.close()


def main():
    XA = rng.multivariate_normal(MEAN_A, COV_A, N_5D)
    XB = rng.multivariate_normal(MEAN_B, COV_B, N_5D)
    X_ds1 = np.vstack([XA, XB])
    y_ds1 = np.concatenate([np.zeros(N_5D, dtype=int), np.ones(N_5D, dtype=int)])

    print("A - Dataset I", X_ds1.shape)
    print("  media A:", XA.mean(axis=0).round(3))
    print("  media B:", XB.mean(axis=0).round(3))
    print(f"  corr A(0,1): {np.corrcoef(XA[:, 0], XA[:, 1])[0, 1]:+.3f}  (positiva)")
    print(f"  corr B(0,1): {np.corrcoef(XB[:, 0], XB[:, 1])[0, 1]:+.3f}  (negativa)")

    XC = sample_shell(N_5D, DIM, RADIUS_C["mu"], RADIUS_C["sigma"])
    XD = sample_shell(N_5D, DIM, RADIUS_D["mu"], RADIUS_D["sigma"])
    X_ds2 = np.vstack([XC, XD])
    y_ds2 = np.concatenate([np.zeros(N_5D, dtype=int), np.ones(N_5D, dtype=int)])

    print("\nB - Dataset II", X_ds2.shape)
    print(f"  raio medio C: {np.linalg.norm(XC, axis=1).mean():.3f}")
    print(f"  raio medio D: {np.linalg.norm(XD, axis=1).mean():.3f}")
    print("  centro C:", XC.mean(axis=0).round(3))
    print("  centro D:", XD.mean(axis=0).round(3))

    pca1, pca2 = PCA(n_components=2), PCA(n_components=2)
    P1 = pca1.fit_transform(X_ds1)
    P2 = pca2.fit_transform(X_ds2)
    evr1 = pca1.explained_variance_ratio_
    evr2 = pca2.explained_variance_ratio_
    figure_4(P1, y_ds1, evr1, P2, y_ds2, evr2, os.path.join(FIG_DIR, "fig4.png"))

    print("\nC.1 / C.2 - Explained variance")
    print(f"  Dataset I : PC1 {evr1[0]:.4f} + PC2 {evr1[1]:.4f} = {evr1.sum():.4f}")
    print(f"  Dataset II: PC1 {evr2[0]:.4f} + PC2 {evr2[1]:.4f} = {evr2.sum():.4f}")

    print("\nC.3 - Distancia entre centros (5D)")
    print(f"  Dataset I : {centre_distance(X_ds1, y_ds1):.4f}")
    print(f"  Dataset II: {centre_distance(X_ds2, y_ds2):.4f}")

    r_ds1 = {"Class A": np.linalg.norm(XA, axis=1),
             "Class B": np.linalg.norm(XB, axis=1)}
    r_ds2 = {"Class C (core)": np.linalg.norm(XC, axis=1),
             "Class D (shell)": np.linalg.norm(XD, axis=1)}
    figure_5(r_ds1, r_ds2, os.path.join(FIG_DIR, "fig5.png"))

    tau = (RADIUS_C["mu"] + RADIUS_D["mu"]) / 2
    pred = separate_dataset_ii(X_ds2, tau)
    print("\nD.3 - Funcao separadora")
    print(f"  tau = {tau:.1f} (meio do caminho entre os raios do enunciado)")
    print(f"  fracao correta: {np.mean(pred == y_ds2):.4f}")

    print("\nFiguras salvas em", os.path.normpath(FIG_DIR))


if __name__ == "__main__":
    main()

"""Exercise 3 - Preparing real-world data for a neural network.

Pre-processa o Spaceship Titanic (train.csv) para uma rede com ativacao tanh:
imputacao, one-hot, TotalSpend, log(1+x) e escala para [-1, 1]. Salva a Figura 6
e imprime todos os numeros da Results summary.

O arquivo train.csv deve estar em docs/exercises/data/dataset/train.csv
(baixe em https://www.kaggle.com/competitions/spaceship-titanic/data).

Uso:  python ex3_preprocessing.py
"""

import os

import numpy as np
import pandas as pd
import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, MinMaxScaler

rng = np.random.default_rng(42)
SEED = 42

HERE = os.path.dirname(os.path.abspath(__file__))
FIG_DIR = os.path.join(HERE, "..", "figures")
CSV_PATH = os.path.join(HERE, "..", "dataset", "train.csv")
os.makedirs(FIG_DIR, exist_ok=True)

SPEND_COLS = ["RoomService", "FoodCourt", "ShoppingMall", "Spa", "VRDeck"]
NUM_COLS = ["Age"] + SPEND_COLS
CAT_COLS = ["HomePlanet", "CryoSleep", "Destination", "VIP"]
DROP_COLS = ["PassengerId", "Name", "Cabin"]
TARGET = "Transported"


def describe(df):
    """Item A: alvo, balanco, tipos, faltantes e estatisticas de gasto."""
    print("A.2 - Balanco de classes")
    for k, v in df[TARGET].value_counts(normalize=True).sort_index().items():
        print(f"  {str(k):<6} {v:.4f}  ({int(v * len(df))} passageiros)")

    print("\nA.3 - Tipos de feature")
    print(f"  numericas   ({len(NUM_COLS)}): {NUM_COLS}")
    print(f"  categoricas ({len(CAT_COLS)}): {CAT_COLS}")
    print(f"  descartadas ({len(DROP_COLS)}): {DROP_COLS}")

    print("\nA.4 - Valores faltantes")
    missing = pd.DataFrame({
        "faltantes": df.isna().sum(),
        "pct": (100 * df.isna().mean()).round(2),
    }).sort_values("faltantes", ascending=False)
    print(missing.to_string())
    print(f"  linhas com ao menos um NaN: {df.isna().any(axis=1).sum()} "
          f"({100 * df.isna().any(axis=1).mean():.1f}%)")

    print("\nA.5 - Colunas de gasto")
    stats = df[SPEND_COLS].agg(["mean", "median", "max", "std"]).T
    stats["pct_zero"] = [100 * (df[c] == 0).mean() for c in SPEND_COLS]
    print(stats.round(2).to_string())
    return missing, stats


def figure_6(raw_fc, scaled_fc, path):
    fig, axes = plt.subplots(1, 2, figsize=(13, 4.8))

    axes[0].hist(raw_fc, bins=60, edgecolor="white", label="FoodCourt (raw)")
    axes[0].set_title("FoodCourt - before preprocessing")
    axes[0].set_xlabel("credits spent")
    axes[0].set_ylabel("count (log scale)")
    axes[0].set_yscale("log")
    axes[0].legend(fontsize=9)
    axes[0].annotate(f"max = {raw_fc.max():,.0f}", xy=(0.55, 0.85),
                     xycoords="axes fraction", fontsize=11)

    axes[1].hist(scaled_fc, bins=60, edgecolor="white", color="seagreen",
                 label="FoodCourt (processed)")
    axes[1].set_title("FoodCourt - after log1p + MinMax to $[-1, 1]$")
    axes[1].set_xlabel("scaled value")
    axes[1].set_ylabel("count")
    axes[1].axvline(-1, color="grey", linestyle=":")
    axes[1].axvline(1, color="grey", linestyle=":")
    axes[1].legend(fontsize=9)

    fig.suptitle("Figure 6 - Effect of preprocessing on a heavy-tailed feature",
                 fontsize=15, fontweight="bold")
    plt.tight_layout()
    plt.savefig(path, dpi=130, bbox_inches="tight")
    plt.close()


def main():
    if not os.path.exists(CSV_PATH):
        raise FileNotFoundError(
            f"train.csv nao encontrado em {os.path.normpath(CSV_PATH)}. "
            "Baixe o Spaceship Titanic no Kaggle e coloque o arquivo la."
        )

    df = pd.read_csv(CSV_PATH)
    print(f"{df.shape[0]} linhas x {df.shape[1]} colunas\n")
    describe(df)

    # ---- B: split antes de qualquer estatistica
    X_raw = df.drop(columns=DROP_COLS + [TARGET])
    y_raw = df[TARGET].astype(int)
    X_tr_raw, X_te_raw, y_tr, y_te = train_test_split(
        X_raw, y_raw, test_size=0.20, stratify=y_raw, random_state=SEED
    )
    print("\nB - Split 80/20 estratificado")
    print(f"  treino {X_tr_raw.shape}  taxa positiva {y_tr.mean():.4f}")
    print(f"  teste  {X_te_raw.shape}  taxa positiva {y_te.mean():.4f}")
    fc_mean = float(X_tr_raw["FoodCourt"].mean())
    fc_median = float(X_tr_raw["FoodCourt"].median())
    print(f"  FoodCourt no treino, antes de transformar: "
          f"media {fc_mean:.4f} | mediana {fc_median:.4f}")

    # ---- C.1: imputacao, ajustada somente no treino
    num_imputer = SimpleImputer(strategy="median")
    cat_imputer = SimpleImputer(strategy="most_frequent")
    num_imputer.fit(X_tr_raw[NUM_COLS])
    cat_imputer.fit(X_tr_raw[CAT_COLS].astype(object))

    def impute(X):
        out = X.copy()
        out[NUM_COLS] = num_imputer.transform(X[NUM_COLS])
        out[CAT_COLS] = cat_imputer.transform(X[CAT_COLS].astype(object))
        return out

    X_tr, X_te = impute(X_tr_raw), impute(X_te_raw)
    print("\nC.1 - Imputacao (valores aprendidos no treino)")
    for c, v in zip(NUM_COLS, num_imputer.statistics_):
        print(f"  {c:<14} mediana -> {v}")
    for c, v in zip(CAT_COLS, cat_imputer.statistics_):
        print(f"  {c:<14} moda    -> {v}")

    # ---- C.2: one-hot; handle_unknown='ignore' cobre categoria so no teste
    ohe = OneHotEncoder(handle_unknown="ignore", sparse_output=False)
    ohe.fit(X_tr[CAT_COLS].astype(str))
    ohe_names = list(ohe.get_feature_names_out(CAT_COLS))
    tr_cat = pd.DataFrame(ohe.transform(X_tr[CAT_COLS].astype(str)),
                          columns=ohe_names, index=X_tr.index)
    te_cat = pd.DataFrame(ohe.transform(X_te[CAT_COLS].astype(str)),
                          columns=ohe_names, index=X_te.index)
    print(f"\nC.2 - One-hot: {len(CAT_COLS)} colunas -> {len(ohe_names)} indicadoras")
    demo = X_te[CAT_COLS].astype(str).head(1).copy()
    demo.iloc[0, 0] = "Pluto"
    n_hp = sum(n.startswith("HomePlanet") for n in ohe_names)
    print(f"  categoria inedita 'Pluto' -> soma do bloco HomePlanet = "
          f"{ohe.transform(demo)[0][:n_hp].sum():.0f}")

    # ---- C.3: TotalSpend
    for X in (X_tr, X_te):
        X["TotalSpend"] = X[SPEND_COLS].sum(axis=1)
    engineered = SPEND_COLS + ["TotalSpend"]

    # ---- C.4: log(1 + x)
    raw_fc = X_tr["FoodCourt"].copy()
    skew_antes = raw_fc.skew()
    for X in (X_tr, X_te):
        for c in engineered:
            X[c] = np.log1p(X[c])
    print(f"\nC.4 - log1p: assimetria de FoodCourt {skew_antes:.3f} -> "
          f"{X_tr['FoodCourt'].skew():.3f}")

    # ---- C.5: escala para [-1, 1]
    numeric_final = ["Age"] + engineered
    scaler = MinMaxScaler(feature_range=(-1, 1))
    scaler.fit(X_tr[numeric_final])
    tr_num = pd.DataFrame(scaler.transform(X_tr[numeric_final]),
                          columns=numeric_final, index=X_tr.index)
    te_num = pd.DataFrame(scaler.transform(X_te[numeric_final]),
                          columns=numeric_final, index=X_te.index)
    X_train_final = pd.concat([tr_num, tr_cat], axis=1)
    X_test_final = pd.concat([te_num, te_cat], axis=1)

    tr_min, tr_max = X_train_final.values.min(), X_train_final.values.max()
    te_min, te_max = X_test_final.values.min(), X_test_final.values.max()
    print(f"\nC.5 - Escala: treino [{tr_min:.4f}, {tr_max:.4f}] | "
          f"teste [{te_min:.4f}, {te_max:.4f}]")

    # ---- D
    figure_6(raw_fc, X_train_final["FoodCourt"], os.path.join(FIG_DIR, "fig6.png"))

    checks = {
        "sem NaN no treino": int(X_train_final.isna().sum().sum()) == 0,
        "sem NaN no teste": int(X_test_final.isna().sum().sum()) == 0,
        "mesmas colunas nos dois": list(X_train_final.columns) == list(X_test_final.columns),
        "valores finitos": bool(np.isfinite(X_train_final.values).all()
                                and np.isfinite(X_test_final.values).all()),
        "treino em [-1, 1]": tr_min >= -1.0001 and tr_max <= 1.0001,
        "teste compativel com tanh": max(abs(te_min), abs(te_max)) < 2.0,
    }
    print("\nD.2 - Checagens finais")
    for nome, ok in checks.items():
        print(f"  [{'OK' if ok else 'FALHOU'}] {nome}")
    print(f"  shape treino: {X_train_final.shape}")
    print(f"  shape teste:  {X_test_final.shape}")

    print("\n=== Valores para a Results summary ===")
    print(f"  10 - share positiva em Transported: {df[TARGET].mean():.4f}")
    print(f"  11 - FoodCourt no treino: media {fc_mean:.4f} | mediana {fc_median:.4f}")
    print(f"  12 - shape do treino: {X_train_final.shape}")
    print(f"  13 - treino [{tr_min:.4f}, {tr_max:.4f}] | teste [{te_min:.4f}, {te_max:.4f}]")


if __name__ == "__main__":
    main()