1. Data

"""Roda os três exercícios em ordem, com um único gerador aleatório, e salva os números.

Uso, a partir da raiz do repositório:

    python docs/exercises/data/code/run_all.py

As figuras vão para docs/exercises/data/figures/ e os números para code/results.json.
O Exercise 3 precisa de code/data/train.csv (Kaggle, competição Spaceship Titanic).
"""

import json

import numpy as np

import ex1_point_clouds
import ex2_nonlinearity
import ex3_spaceship
from common import CODE_DIR, SEED


def main():
    rng = np.random.default_rng(SEED)  # o mesmo gerador em todo o relatório
    results = {
        "exercise1": ex1_point_clouds.run(rng),
        "exercise2": ex2_nonlinearity.run(rng),
        "exercise3": ex3_spaceship.run(),  # não sorteia nada; o split usa random_state=SEED
    }
    (CODE_DIR / "results.json").write_text(json.dumps(results, indent=2, ensure_ascii=False) + "\n")
    print(f"Números salvos em {CODE_DIR / 'results.json'}")


if __name__ == "__main__":
    main()

"""Configuração compartilhada pelos três exercícios: semente, pastas e gravação das figuras."""

from pathlib import Path

import matplotlib

matplotlib.use("Agg")  # gera os PNG sem abrir janela
import matplotlib.pyplot as plt  # noqa: E402

SEED = 42
CODE_DIR = Path(__file__).resolve().parent
FIGURES = CODE_DIR.parent / "figures"
DATA_DIR = CODE_DIR / "data"


def save(fig, name):
    """Salva a figura em figures/ e libera a memória."""
    FIGURES.mkdir(parents=True, exist_ok=True)
    fig.savefig(FIGURES / name, dpi=150, bbox_inches="tight")
    plt.close(fig)

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

Gera as 4 classes gaussianas do enunciado, repete a geração com os desvios padrão
multiplicados por s e mede o quanto as nuvens se misturam. Produz as Figuras 1, 2 e 3.
Nenhum modelo é treinado: todas as medidas são geométricas.
"""

from itertools import combinations

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.colors import ListedColormap
from matplotlib.lines import Line2D

from common import save

# Parâmetros do enunciado: média (x, y) e desvio padrão (x, y) de cada classe.
MEANS = np.array([[2.0, 3.0], [5.0, 6.0], [8.0, 1.0], [15.0, 4.0]])
STDS = np.array([[0.8, 2.5], [1.2, 1.9], [0.9, 0.9], [0.5, 2.0]])
N_PER_CLASS = 100
CLASSES = range(len(MEANS))
SCALES = [0.5, 1.0, 2.0, 4.0]
COLORS = ["tab:blue", "tab:orange", "tab:green", "tab:red"]


def generate(rng, s=1.0):
    """Amostra 100 pontos por classe. As médias ficam fixas; só o desvio muda (× s)."""
    X = np.vstack([rng.normal(MEANS[k], STDS[k] * s, size=(N_PER_CLASS, 2)) for k in CLASSES])
    y = np.repeat(np.arange(len(MEANS)), N_PER_CLASS)
    return X, y


def separation_ratios(s=1.0):
    """r_ij = ||mu_i - mu_j|| / (sigma_i + sigma_j), com sigma_k = média dos dois desvios da classe k."""
    sigma_bar = (STDS * s).mean(axis=1)
    return {
        (i, j): float(np.linalg.norm(MEANS[i] - MEANS[j]) / (sigma_bar[i] + sigma_bar[j]))
        for i, j in combinations(CLASSES, 2)
    }


def nearest_center(X):
    """Índice do centro de classe (média do enunciado) mais próximo de cada ponto."""
    # dist[n, k]: distância euclidiana do ponto n ao centro da classe k.
    dist = np.linalg.norm(X[:, None, :] - MEANS[None, :, :], axis=2)
    return dist.argmin(axis=1)


def mixing_rate(X, y):
    """Fração de pontos cujo centro mais próximo não é o da própria classe."""
    return float(np.mean(nearest_center(X) != y))


def mixing_counts(X, y):
    """counts[k, m]: pontos da classe k cujo centro mais próximo é o da classe m."""
    counts = np.zeros((len(MEANS), len(MEANS)), dtype=int)
    np.add.at(counts, (y, nearest_center(X)), 1)
    return counts


def most_likely_class(xx, yy):
    """Classe de maior densidade em cada ponto da grade, com as gaussianas verdadeiras (s = 1).

    Não é um modelo treinado: usa só os parâmetros do enunciado. Serve de esboço da
    fronteira que uma rede bem treinada tende a aproximar.
    """
    grid = np.column_stack([xx.ravel(), yy.ravel()])
    z = (grid[:, None, :] - MEANS[None]) / STDS[None]
    # log da densidade gaussiana com covariância diagonal, sem a constante comum a todas as classes.
    log_density = -0.5 * (z**2).sum(axis=2) - np.log(STDS).sum(axis=1)
    return log_density.argmax(axis=1).reshape(xx.shape)


def plot_clouds(ax, X, y, marker_size=14):
    """Desenha os pontos de cada classe e marca o centro (média) de cada nuvem."""
    for k in CLASSES:
        ax.scatter(*X[y == k].T, s=marker_size, alpha=0.65, color=COLORS[k], label=f"Classe {k}")
    ax.scatter(*MEANS.T, marker="X", s=140, color="black", edgecolors="white",
               linewidths=1.0, zorder=3, label="Centro (média)")
    ax.set_xlabel("$x_1$")
    ax.set_ylabel("$x_2$")


def figure1(X, y, name, title, boundaries=False):
    """Figura 1: as 4 nuvens com os centros. Com boundaries=True, acrescenta o esboço do item C."""
    fig, ax = plt.subplots(figsize=(9, 5.5), layout="constrained")
    xlim, ylim = (-2.0, 18.0), (-6.0, 12.0)
    handles = []
    if boundaries:
        xx, yy = np.meshgrid(np.linspace(*xlim, 800), np.linspace(*ylim, 800))
        regions = most_likely_class(xx, yy)
        ax.contourf(xx, yy, regions, levels=np.arange(-0.5, len(MEANS)),
                    cmap=ListedColormap(COLORS), alpha=0.12)
        for k in CLASSES:  # contorno de cada região: as linhas se sobrepõem na fronteira
            ax.contour(xx, yy, (regions == k).astype(float), levels=[0.5], colors="black", linewidths=1.4)
        handles.append(Line2D([], [], color="black", lw=1.4, label="Fronteira esboçada"))
    plot_clouds(ax, X, y)
    for k in CLASSES:
        ax.annotate(f"$\\mu_{k}$", MEANS[k], textcoords="offset points", xytext=(8, 8),
                    fontsize=12, fontweight="bold")
    ax.set_xlim(xlim)
    ax.set_ylim(ylim)
    ax.set_title(title)
    point_handles, _ = ax.get_legend_handles_labels()
    ax.legend(handles=point_handles + handles, loc="upper left", bbox_to_anchor=(1.01, 1.0))
    save(fig, name)


def figure2(datasets, rates):
    """Figura 2: um painel por fator de escala, todos com os mesmos limites de eixo."""
    points = np.vstack([X for X, _ in datasets.values()])
    pad = 1.0
    fig, axes = plt.subplots(2, 2, figsize=(11, 9), sharex=True, sharey=True, layout="constrained")
    for ax, s in zip(axes.flat, SCALES):
        plot_clouds(ax, *datasets[s], marker_size=8)
        ax.set_title(f"s = {s}  —  mixing rate = {100 * rates[s]:.2f}%")
        ax.set_xlim(points[:, 0].min() - pad, points[:, 0].max() + pad)
        ax.set_ylim(points[:, 1].min() - pad, points[:, 1].max() + pad)
    handles, labels = axes.flat[0].get_legend_handles_labels()
    fig.legend(handles, labels, loc="outside lower center", ncol=5)
    fig.suptitle("Figura 2 — As mesmas 4 classes em 4 fatores de escala (eixos compartilhados)")
    save(fig, "fig2_scales.png")


def figure3(rates, r_min, pair):
    """Figura 3: mixing rate × s, com o menor r_ij (que cai como 1/s) no eixo da direita."""
    fig, ax = plt.subplots(figsize=(8.5, 5), layout="constrained")
    values = [100 * rates[s] for s in SCALES]
    ax.plot(SCALES, values, "o-", color="tab:purple", lw=2, label="Mixing rate (%)")
    for s, v in zip(SCALES, values):
        ax.annotate(f"{v:.2f}%", (s, v), textcoords="offset points", xytext=(0, 9), ha="center")
    ax.set_ylim(-3, max(values) + 8)  # espaço para os rótulos acima dos pontos
    ax.set_xscale("log", base=2)
    ax.set_xticks(SCALES, [str(s) for s in SCALES])
    ax.set_xlabel("Fator de escala s (escala log)")
    ax.set_ylabel("Mixing rate (%)")

    ax2 = ax.twinx()
    ax2.plot(SCALES, [r_min / s for s in SCALES], "s--", color="gray",
             label=f"Menor $r_{{ij}}$ (par {pair[0]}–{pair[1]}) = {r_min:.2f} / s")
    ax2.axhline(1.0, color="gray", lw=0.8, ls=":", label="$r_{ij} = 1$")
    ax2.set_ylabel("Menor $r_{ij}$")

    h1, l1 = ax.get_legend_handles_labels()
    h2, l2 = ax2.get_legend_handles_labels()
    ax.legend(h1 + h2, l1 + l2, loc="center left")
    ax.set_title("Figura 3 — Mixing rate × fator de escala s")
    save(fig, "fig3_mixing_rate.png")


def run(rng):
    # A — gera as nuvens originais (s = 1) e desenha a Figura 1.
    X, y = generate(rng, 1.0)
    figure1(X, y, "fig1_point_clouds.png", "Figura 1 — Nuvens de pontos das 4 classes (s = 1)")

    # B — as mesmas 4 classes em 4 escalas. O dataset de s = 1 é o próprio dataset do item A.
    datasets = {s: (X, y) if s == 1.0 else generate(rng, s) for s in SCALES}
    rates = {s: mixing_rate(*datasets[s]) for s in SCALES}
    ratios = separation_ratios(1.0)
    pair, r_min = min(ratios.items(), key=lambda item: item[1])
    figure2(datasets, rates)
    figure3(rates, r_min, pair)

    # C — esboço das fronteiras sobre a Figura 1.
    figure1(X, y, "fig1_boundaries.png",
            "Figura 1 (item C) — Esboço das fronteiras de decisão sobre as nuvens (s = 1)",
            boundaries=True)

    print("Exercise 1")
    for (i, j), r in ratios.items():
        print(f"  r_{i}{j} = {r:.3f}")
    for s in SCALES:
        print(f"  s = {s}: mixing rate = {100 * rates[s]:.2f}%")

    return {
        "separation_ratios_s1": {f"{i}-{j}": r for (i, j), r in ratios.items()},
        "smallest_ratio_pair": f"{pair[0]}-{pair[1]}",
        "smallest_ratio_s1": r_min,
        "smallest_ratio_s2": r_min / 2,
        "smallest_ratio_s2_direct": separation_ratios(2.0)[pair],  # confere que r escala com 1/s
        "mixing_rate": {str(s): rates[s] for s in SCALES},
        "mixing_counts": {str(s): mixing_counts(*datasets[s]).tolist() for s in SCALES},
    }

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

Dataset I: duas gaussianas 5D deslocadas. Dataset II: núcleo e casca concêntricos em 5D.
Compara os dois com PCA (Figura 4), distância entre centros e histograma do raio (Figura 5).
"""

import matplotlib.pyplot as plt
import numpy as np
from sklearn.decomposition import PCA

from common import save

N_PER_CLASS = 500
DIM = 5

MU_A = np.zeros(DIM)
SIGMA_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],
])
MU_B = np.full(DIM, 1.5)
SIGMA_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],
])

# Raio das cascas: rho ~ N(média, 0.4), com 0.4 lido como desvio padrão (convenção do NumPy).
RADIUS_C, RADIUS_D, RADIUS_STD = 2.0, 5.0, 0.4
THRESHOLD = (RADIUS_C + RADIUS_D) / 2  # raio no meio do caminho entre núcleo e casca: 3.5

CLASS_COLORS = ["tab:blue", "tab:red"]


def check_covariance(cov):
    """Uma covariância válida é simétrica e positiva definida (todos os autovalores > 0)."""
    eigenvalues = np.linalg.eigvalsh(cov)
    if not np.allclose(cov, cov.T) or eigenvalues.min() <= 0:
        raise ValueError(f"covariância inválida, autovalores = {eigenvalues}")
    return float(eigenvalues.min())


def dataset_gaussians(rng):
    """Dataset I: classe A ~ N(mu_A, Sigma_A) e classe B ~ N(mu_B, Sigma_B), 500 pontos cada."""
    # method="cholesky": a decomposição de Cholesky é única, então o resultado não muda de máquina.
    Xa = rng.multivariate_normal(MU_A, SIGMA_A, size=N_PER_CLASS, method="cholesky")
    Xb = rng.multivariate_normal(MU_B, SIGMA_B, size=N_PER_CLASS, method="cholesky")
    return np.vstack([Xa, Xb]), np.repeat([0, 1], N_PER_CLASS)


def shell(rng, radius_mean):
    """Pontos x = rho * u, com u uniforme na esfera unitária de R^5."""
    v = rng.standard_normal((N_PER_CLASS, DIM))
    u = v / np.linalg.norm(v, axis=1, keepdims=True)  # cada linha passa a ter norma 1
    rho = rng.normal(radius_mean, RADIUS_STD, size=N_PER_CLASS)
    return rho[:, None] * u


def dataset_shells(rng):
    """Dataset II: classe C (núcleo, raio ~2) e classe D (casca, raio ~5), 500 pontos cada."""
    return np.vstack([shell(rng, RADIUS_C), shell(rng, RADIUS_D)]), np.repeat([0, 1], N_PER_CLASS)


def radial_rule(X):
    """f(x) = ||x||^2 - 3.5^2. f > 0 prevê casca (D); f < 0 prevê núcleo (C)."""
    return (X**2).sum(axis=1) - THRESHOLD**2


def figure4(datasets):
    """Figura 4: PCA em 2D de cada dataset, lado a lado. Devolve a variância explicada."""
    fig, axes = plt.subplots(1, 2, figsize=(12, 5.4), layout="constrained")
    explained = {}
    for ax, (key, (title, X, y, names)) in zip(axes, datasets.items()):
        pca = PCA(n_components=2, svd_solver="full").fit(X)  # o PCA centraliza os dados sozinho
        Z = pca.transform(X)
        ratio = pca.explained_variance_ratio_
        explained[key] = ratio.tolist()
        for c in (0, 1):
            ax.scatter(*Z[y == c].T, s=10, alpha=0.55, color=CLASS_COLORS[c], label=names[c])
        ax.set_title(f"{title}: PC1 + PC2 = {100 * ratio.sum():.1f}% da variância")
        ax.set_xlabel(f"PC1 ({100 * ratio[0]:.1f}% da variância)")
        ax.set_ylabel(f"PC2 ({100 * ratio[1]:.1f}% da variância)")
        ax.set_aspect("equal", adjustable="datalim")
        ax.legend(loc="upper right")
    fig.suptitle("Figura 4 — Projeção PCA em 2D dos dois datasets 5D")
    save(fig, "fig4_pca.png")
    return explained


def figure5(datasets, radii):
    """Figura 5: histograma do raio ||x|| em 5D, com as duas classes no mesmo eixo."""
    fig, axes = plt.subplots(1, 2, figsize=(12, 4.6), layout="constrained")
    for ax, (key, (title, _, y, names)) in zip(axes, datasets.items()):
        bins = np.histogram_bin_edges(radii[key], bins=40)
        for c in (0, 1):
            ax.hist(radii[key][y == c], bins=bins, alpha=0.6, color=CLASS_COLORS[c], label=names[c])
        ax.set_title(title)
        ax.set_xlabel("Raio $\\|x\\|$ (calculado em 5D)")
        ax.set_ylabel("Número de pontos")
        ax.legend(loc="best")
    axes[1].axvline(THRESHOLD, color="black", ls="--", lw=1.2)
    axes[1].annotate(f"$\\|x\\| = {THRESHOLD}$", (THRESHOLD, axes[1].get_ylim()[1] * 0.9),
                     xytext=(6, 0), textcoords="offset points")
    fig.suptitle("Figura 5 — Histograma do raio de cada ponto, por classe")
    save(fig, "fig5_radius.png")


def run(rng):
    # A — Dataset I. Antes de amostrar, confere se as covariâncias do enunciado são válidas.
    min_eigenvalues = {"Sigma_A": check_covariance(SIGMA_A), "Sigma_B": check_covariance(SIGMA_B)}
    X1, y1 = dataset_gaussians(rng)

    # B — Dataset II.
    X2, y2 = dataset_shells(rng)

    datasets = {
        "dataset_I": ("Dataset I (gaussianas)", X1, y1, ("Classe A", "Classe B")),
        "dataset_II": ("Dataset II (cascas)", X2, y2, ("Classe C (núcleo)", "Classe D (casca)")),
    }

    # C — PCA e medidas geométricas, sempre nos dados 5D originais.
    explained = figure4(datasets)
    center_distance = {
        key: float(np.linalg.norm(X[y == 0].mean(axis=0) - X[y == 1].mean(axis=0)))
        for key, (_, X, y, _) in datasets.items()
    }
    radii = {key: np.linalg.norm(X, axis=1) for key, (_, X, _, _) in datasets.items()}
    figure5(datasets, radii)

    # D — uma função das entradas que separa o Dataset II.
    predicted_shell = radial_rule(X2) > 0
    rule_accuracy = float(np.mean(predicted_shell == (y2 == 1)))

    print("Exercise 2")
    for key in datasets:
        print(f"  {key}: distância entre centros = {center_distance[key]:.3f}, "
              f"PC1+PC2 = {100 * sum(explained[key]):.1f}%")
    print(f"  regra ||x||^2 > {THRESHOLD ** 2}: acurácia no Dataset II = {100 * rule_accuracy:.1f}%")

    radius_stats = {
        key: {
            str(c): {"mean": float(r[y == c].mean()), "min": float(r[y == c].min()), "max": float(r[y == c].max())}
            for c in (0, 1)
        }
        for key, (_, _, y, _) in datasets.items()
        for r in [radii[key]]
    }
    return {
        "min_eigenvalues": min_eigenvalues,
        "explained_variance": explained,
        "explained_variance_pc1_pc2": {key: float(sum(v)) for key, v in explained.items()},
        "center_distance_5d": center_distance,
        "center_distance_theory_dataset_I": float(np.linalg.norm(MU_B - MU_A)),
        "radius_stats": radius_stats,
        "radial_rule_threshold_squared": THRESHOLD**2,
        "radial_rule_accuracy_dataset_II": rule_accuracy,
    }

"""Exercise 3 — Preparing real-world data for a neural network (Spaceship Titanic).

Descreve o train.csv, separa treino e teste ANTES de qualquer estatística e prepara as
features para uma rede com ativação tanh. Produz a figura auxiliar do item C e a Figura 6.
"""

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.impute import SimpleImputer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder, StandardScaler

from common import DATA_DIR, SEED, save

TARGET = "Transported"
SPEND = ["RoomService", "FoodCourt", "ShoppingMall", "Spa", "VRDeck"]
NUMERIC = ["Age", *SPEND]
CATEGORICAL = ["HomePlanet", "CryoSleep", "Destination", "VIP"]
DROPPED = ["Cabin", "Name", "PassengerId"]
LOG_COLUMNS = [*SPEND, "TotalSpend"]
SCALED = ["Age", *LOG_COLUMNS]

CLASS_NAMES = {0: "Transported = False", 1: "Transported = True"}
CLASS_COLORS = {0: "tab:blue", 1: "tab:orange"}


def describe(df):
    """A — balanço do alvo, valores ausentes e estatísticas dos gastos (arquivo train.csv inteiro)."""
    missing = df.isna().sum()
    return {
        "rows": len(df),
        "columns": list(df.columns),
        "balance": {str(k): float(v) for k, v in df[TARGET].value_counts(normalize=True).items()},
        "missing": {
            col: {"count": int(missing[col]), "percent": float(100 * missing[col] / len(df))}
            for col in df.columns
        },
        "spend_stats": {
            col: {"mean": float(df[col].mean()), "median": float(df[col].median()), "max": float(df[col].max())}
            for col in SPEND
        },
    }


class TanhPreprocessor:
    """Aprende todas as estatísticas no treino (fit) e aplica as mesmas ao teste (transform)."""

    def fit(self, X):
        X = X.drop(columns=DROPPED)
        # Numéricas: mediana do treino. Os gastos têm cauda longa; a média seria puxada pelos extremos.
        self.num_imputer = SimpleImputer(strategy="median").fit(X[NUMERIC])
        # Categóricas: categoria mais frequente do treino.
        self.cat_imputer = SimpleImputer(strategy="most_frequent").fit(X[CATEGORICAL].astype(object))
        X = self._impute_and_engineer(X)
        self.scaler = StandardScaler().fit(X[SCALED])
        # handle_unknown="ignore": categoria nova no teste vira um vetor só de zeros, sem erro.
        self.encoder = OneHotEncoder(handle_unknown="ignore", sparse_output=False).fit(X[CATEGORICAL])
        return self

    def _impute_and_engineer(self, X):
        """Imputação, TotalSpend e log(1 + x). Usa só objetos já ajustados no treino."""
        X = X.copy()
        X[NUMERIC] = self.num_imputer.transform(X[NUMERIC])
        X[CATEGORICAL] = self.cat_imputer.transform(X[CATEGORICAL].astype(object)).astype(str)
        X["TotalSpend"] = X[SPEND].sum(axis=1)  # soma depois da imputação, para não somar NaN
        X[LOG_COLUMNS] = np.log1p(X[LOG_COLUMNS])  # log(1 + x) comprime a cauda longa dos gastos
        return X

    def transform(self, X):
        X = self._impute_and_engineer(X.drop(columns=DROPPED))
        scaled = self.scaler.transform(X[SCALED])  # média 0 e desvio 1, com a média e o desvio do treino
        onehot = self.encoder.transform(X[CATEGORICAL])
        columns = [*SCALED, *self.encoder.get_feature_names_out(CATEGORICAL)]
        return pd.DataFrame(np.hstack([scaled, onehot]), columns=columns, index=X.index)


def hist_by_class(ax, values, y, bins):
    """Histograma sobreposto das duas classes do alvo."""
    for c in (0, 1):
        ax.hist(values[y == c].dropna(), bins=bins, alpha=0.6, color=CLASS_COLORS[c], label=CLASS_NAMES[c])
    ax.set_ylabel("Número de passageiros")
    ax.legend(loc="upper right")


def figure_before_after(before, after, y, name, title, after_label):
    fig, axes = plt.subplots(1, 2, figsize=(12, 4.6), layout="constrained")
    for ax, values, label in [(axes[0], before, "valor original"), (axes[1], after, after_label)]:
        hist_by_class(ax, values, y, np.histogram_bin_edges(values.dropna(), bins=50))
        ax.set_xlabel(f"{values.name} — {label}")
    axes[0].set_title("Antes")
    axes[1].set_title("Depois")
    fig.suptitle(title)
    save(fig, name)


def run():
    df = pd.read_csv(DATA_DIR / "train.csv")

    # A — conhecer os dados.
    description = describe(df)

    # B — separar ANTES de calcular qualquer estatística de transformação.
    X = df.drop(columns=[TARGET])
    y = df[TARGET].astype(int)
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, stratify=y, random_state=SEED
    )

    # C — pré-processar: fit só no treino, transform no treino e no teste.
    prep = TanhPreprocessor().fit(X_train)
    Xtr = prep.transform(X_train)
    Xte = prep.transform(X_test)

    # Categoria que não existe no treino: HomePlanet = "Pluto".
    unknown = X_train.iloc[[0]].copy()
    unknown["HomePlanet"] = "Pluto"
    unknown_encoded = prep.transform(unknown)
    unknown_onehot = {c: float(unknown_encoded[c].iloc[0]) for c in unknown_encoded if c.startswith("HomePlanet_")}

    log_example = np.log1p(X_train["RoomService"]).rename("RoomService")
    figure_before_after(X_train["RoomService"], log_example, y_train, "fig_c_log1p_roomservice.png",
                        "Figura auxiliar (item C) — RoomService antes e depois de log(1 + x), treino",
                        "log(1 + x)")

    # D — verificar e visualizar.
    figure_before_after(X_train["FoodCourt"], Xtr["FoodCourt"], y_train, "fig6_foodcourt.png",
                        "Figura 6 — FoodCourt antes e depois do pré-processamento, treino",
                        "imputado, log(1 + x) e padronizado")

    # Comparação: gastos imputados e padronizados SEM log(1 + x). Só mede o efeito do log;
    # não entra na matriz final.
    medians = dict(zip(NUMERIC, prep.num_imputer.statistics_))
    raw_spend = X_train[SPEND].fillna({col: medians[col] for col in SPEND})
    z_without_log = (raw_spend - raw_spend.mean()) / raw_spend.std(ddof=0)

    checks = {
        "max_z_without_log_train": {c: float(z_without_log[c].max()) for c in SPEND},
        "share_abs_above_3_without_log_train": float((z_without_log.abs() > 3).to_numpy().mean()),
        "nan_train": int(Xtr.isna().sum().sum()),
        "nan_test": int(Xte.isna().sum().sum()),
        "shape_train": list(Xtr.shape),
        "shape_test": list(Xte.shape),
        "min_train": float(Xtr.to_numpy().min()),
        "max_train": float(Xtr.to_numpy().max()),
        "min_test": float(Xte.to_numpy().min()),
        "max_test": float(Xte.to_numpy().max()),
        "scaled_mean_train": {c: float(Xtr[c].mean()) for c in SCALED},
        "scaled_std_train": {c: float(Xtr[c].std(ddof=0)) for c in SCALED},
        "scaled_min_max_train": {c: [float(Xtr[c].min()), float(Xtr[c].max())] for c in SCALED},
        "scaled_min_max_test": {c: [float(Xte[c].min()), float(Xte[c].max())] for c in SCALED},
        "share_abs_above_3_train": float((Xtr[SCALED].abs() > 3).to_numpy().mean()),
    }

    print("Exercise 3")
    print(f"  treino {Xtr.shape}, teste {Xte.shape}, NaN = {checks['nan_train']} / {checks['nan_test']}")
    print(f"  faixa treino [{checks['min_train']:.3f}, {checks['max_train']:.3f}], "
          f"teste [{checks['min_test']:.3f}, {checks['max_test']:.3f}]")

    return {
        "description": description,
        "split": {
            "train_rows": len(X_train),
            "test_rows": len(X_test),
            "positive_share_train": float(y_train.mean()),
            "positive_share_test": float(y_test.mean()),
        },
        "foodcourt_train_before": {
            "mean": float(X_train["FoodCourt"].mean()),
            "median": float(X_train["FoodCourt"].median()),
        },
        "imputation_values": {
            "numeric_median": dict(zip(NUMERIC, prep.num_imputer.statistics_.tolist())),
            "categorical_mode": dict(zip(CATEGORICAL, map(str, prep.cat_imputer.statistics_))),
        },
        "features": list(Xtr.columns),
        "unknown_category_onehot": unknown_onehot,
        "checks": checks,
    }