Unedited: a first encounter with titanic

import pandas as pd

df = pd.read_csv(DATA / "titanic.csv")
print("shape:", df.shape)
print()
print(df.dtypes.to_string())

show(df.head(5))

print(df.survived.value_counts(normalize=True).sort_index().to_string())
print()
print(f"If the model says 'died' to EVERYONE, accuracy = {1 - df.survived.mean():.4f}")

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.dummy import DummyClassifier
from sklearn.metrics import accuracy_score

X, y = df.drop(columns=["survived"]), df["survived"]
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)

def build_pipe(num, cat):
    return Pipeline([
        ("prep", ColumnTransformer([
            ("num", Pipeline([("impute", SimpleImputer(strategy="median")),
                              ("scale", StandardScaler())]), num),
            ("cat", Pipeline([("impute", SimpleImputer(strategy="most_frequent")),
                              ("encode", OneHotEncoder(handle_unknown="ignore"))]), cat),
        ])),
        ("model", LogisticRegression(max_iter=3000)),
    ])

baseline = accuracy_score(y_te, DummyClassifier(strategy="most_frequent")
                          .fit(X_tr[["pclass"]], y_tr).predict(X_te[["pclass"]]))

num = X.select_dtypes(include=[np.number, bool]).columns.tolist()
cat = [c for c in X.columns if c not in num]
print("numeric columns:", num)
print("text columns   :", cat)

q1 = build_pipe(num, cat).fit(X_tr, y_tr)
a1 = accuracy_score(y_te, q1.predict(X_te))
print()
print(f"BASELINE  : {baseline:.4f}")
print(f"Attempt 1 : {a1:.4f}")

for col in cat:
    table = df.groupby(col, dropna=False).survived.agg(["count", "mean"])
    exact = ((table["mean"] == 0) | (table["mean"] == 1)).all()
    flag = "   <-- SEPARATES THE TARGET COMPLETELY" if exact else ""
    print(f"{col}:{flag}")
    print(table.round(3).to_string())
    print()

print("values of the alive column:", df.alive.unique().tolist())
print("does 'alive == yes' MATCH 'survived == 1':",
      bool(((df.alive == "yes") == (df.survived == 1)).all()))

X2_tr, X2_te = X_tr.drop(columns=["alive"]), X_te.drop(columns=["alive"])
num2 = [c for c in num if c != "alive"]
cat2 = [c for c in cat if c != "alive"]

q2 = build_pipe(num2, cat2).fit(X2_tr, y_tr)
a2 = accuracy_score(y_te, q2.predict(X2_te))
print(f"BASELINE  : {baseline:.4f}")
print(f"Attempt 1 : {a1:.4f}   (leakage)")
print(f"Attempt 2 : {a2:.4f}   (alive dropped)")

missing = df.isna().sum()
missing = missing[missing > 0].sort_values(ascending=False)
for col, n in missing.items():
    print(f"  {col:14s} {n:3d} missing  ({n/len(df):.1%})")

X3_tr, X3_te = X2_tr.drop(columns=["deck"]), X2_te.drop(columns=["deck"])
num3 = [c for c in num2 if c != "deck"]
cat3 = [c for c in cat2 if c != "deck"]

q3 = build_pipe(num3, cat3).fit(X3_tr, y_tr)
a3 = accuracy_score(y_te, q3.predict(X3_te))
print(f"Attempt 2 : {a2:.4f}   (deck kept, 77% filled in)")
print(f"Attempt 3 : {a3:.4f}   (deck dropped)")
print(f"Change    : {a3 - a2:+.4f}")

print("class  ~  pclass:")
print(df.groupby("pclass")["class"].unique().to_string())
print()
print("adult_male  ==  (sex=='male' and age>=18):",
      bool((df.adult_male == ((df.sex == "male") & (df.age >= 18))).all()))
print("alone       ==  (sibsp + parch == 0)     :",
      bool((df.alone == ((df.sibsp + df.parch) == 0)).all()))
print("who         values                       :", df.who.unique().tolist())
print("embark_town ~ embarked                   :",
      df.groupby("embarked")["embark_town"].unique().to_dict())

show(pd.DataFrame([
    {"Column": "class", "Computed from": "pclass (1→First, 2→Second, 3→Third)"},
    {"Column": "adult_male", "Computed from": "sex and age"},
    {"Column": "alone", "Computed from": "sibsp + parch"},
    {"Column": "who", "Computed from": "sex and age (man/woman/child)"},
    {"Column": "embark_town", "Computed from": "embarked (S→Southampton, ...)"},
]))

honest = ["pclass", "sex", "age", "sibsp", "parch", "fare", "embarked"]
num4 = ["pclass", "age", "sibsp", "parch", "fare"]
cat4 = ["sex", "embarked"]

q4 = build_pipe(num4, cat4).fit(X_tr[honest], y_tr)
a4 = accuracy_score(y_te, q4.predict(X_te[honest]))
print(f"Attempt 3 : {a3:.4f}   (13 columns)")
print(f"Attempt 4 : {a4:.4f}   (7 'honest' columns)")
print(f"Change    : {a4 - a3:+.4f}")

from sklearn.model_selection import cross_val_score

cv3 = cross_val_score(build_pipe(num3, cat3), X.drop(columns=["alive", "deck"]), y, cv=5)
cv4 = cross_val_score(build_pipe(num4, cat4), X[honest], y, cv=5)

print("Attempt 3 (13 columns):")
print("  folds:", cv3.round(4).tolist())
print(f"  mean: {cv3.mean():.4f}  ±{cv3.std():.4f}")
print()
print("Attempt 4 (7 columns):")
print("  folds:", cv4.round(4).tolist())
print(f"  mean: {cv4.mean():.4f}  ±{cv4.std():.4f}")
print()
print(f"Gap between the means: {abs(cv3.mean() - cv4.mean()):.4f}")
print(f"Spread of the folds  : ±{max(cv3.std(), cv4.std()):.4f}")

show(pd.DataFrame([
    {"Attempt": "0. Baseline ('died' for everyone)", "Accuracy": f"{baseline:.4f}", "Conclusion": "The pass mark"},
    {"Attempt": "1. All 14 columns", "Accuracy": f"{a1:.4f}", "Conclusion": "LEAKAGE: alive = the target"},
    {"Attempt": "2. alive dropped", "Accuracy": f"{a2:.4f}", "Conclusion": "The first honest number"},
    {"Attempt": "3. deck dropped too (77% empty)", "Accuracy": f"{a3:.4f}", "Conclusion": "Fewer columns, a better result"},
    {"Attempt": "4. Only 7 'honest' columns", "Accuracy": f"{a4:.4f}", "Conclusion": "My hypothesis was REJECTED"},
    {"Attempt": "CV: attempt 3", "Accuracy": f"{cv3.mean():.4f} ±{cv3.std():.4f}", "Conclusion": "The real estimate: 13 columns lead"},
    {"Attempt": "CV: attempt 4", "Accuracy": f"{cv4.mean():.4f} ±{cv4.std():.4f}", "Conclusion": "The ranges overlap: confidence is limited"},
]))

show(pd.DataFrame([
    {"Mistake": "I gave every column to the model", "Consequence": "1.0000: a false result",
     "Lesson": "Group every column by the target"},
    {"Mistake": "I filled a 77%-empty column", "Consequence": "The result was lower",
     "Lesson": "A mostly empty column isn't filled, it's dropped"},
    {"Mistake": "I dropped the repeating columns", "Consequence": "The result got worse",
     "Lesson": "Drop 'redundant' columns by measuring, not by thinking"},
    {"Mistake": "I trusted one split", "Consequence": "The gap turned out real, but the ranges overlap",
     "Lesson": "CV: look at the fold range, NOT just the mean"},
]))