The baseline and the first model

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.dummy import DummyClassifier
from sklearn.metrics import accuracy_score, f1_score

df = pd.read_csv(DATA / "uy_ijara.csv")
num = ["xonalar", "maydon_m2", "qavat", "qavatlar_soni", "metro_km", "mebel", "qurilgan_yil"]
X, y = df[num + ["tuman"]], df["ijaraga_berildi_30k"]
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)

print(f"Target ratio: {y.mean():.1%} 'yes'")

strategies = {
    "most_frequent": "Always says the most common class",
    "stratified": "Guesses at random, following the class ratio",
    "uniform": "Flips a coin (equal odds)",
    "prior": "Predicts the same as most_frequent",
}
rows = []
for s, note in strategies.items():
    d = DummyClassifier(strategy=s, random_state=42).fit(X_tr[num], y_tr)
    b = d.predict(X_te[num])
    rows.append({"Strategy": s, "Accuracy": round(accuracy_score(y_te, b), 4),
                 "F1": round(f1_score(y_te, b, zero_division=0), 4), "What it does": note})
show(pd.DataFrame(rows))

baseline = accuracy_score(y_te, DummyClassifier(strategy="most_frequent")
                          .fit(X_tr[num], y_tr).predict(X_te[num]))
print(f"BASELINE = {baseline:.4f}")
print()
print("Write this number in your notebook. Every later result is compared to it.")

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

pipe = Pipeline([
    ("prep", ColumnTransformer([
        ("num", Pipeline([("impute", SimpleImputer(strategy="median")),
                          ("scale", StandardScaler())]), num),
        ("cat", OneHotEncoder(handle_unknown="ignore"), ["tuman"]),
    ])),
    ("model", LogisticRegression(max_iter=2000)),
]).fit(X_tr, y_tr)

model_acc = accuracy_score(y_te, pipe.predict(X_te))
print(f"BASELINE: {baseline:.4f}")
print(f"MODEL   : {model_acc:.4f}")
print(f"Gap     : {model_acc - baseline:+.4f}")
print()
print("Verdict:", "PASSED, the model really learned" if model_acc > baseline + 0.02 else "FAILED")

td = pd.read_csv(DATA / "talaba_bitirdi.csv", keep_default_na=False, na_values=[""])
feats = ["kirish_bali", "davomat_foiz", "uy_vazifa_bali", "ishlaydi", "masofa_km"]
Xt, yt = td[feats], td["bitirdi"]
Xt_tr, Xt_te, yt_tr, yt_te = train_test_split(Xt, yt, test_size=0.3, random_state=42, stratify=yt)

baseline_t = accuracy_score(yt_te, DummyClassifier(strategy="most_frequent")
                            .fit(Xt_tr, yt_tr).predict(Xt_te))
model_t = LogisticRegression(max_iter=2000).fit(Xt_tr, yt_tr)
acc_t = accuracy_score(yt_te, model_t.predict(Xt_te))

print(f"Target ratio : {yt.mean():.1%} graduated")
print(f"BASELINE     : {baseline_t:.4f}")
print(f"MODEL        : {acc_t:.4f}")
print(f"Gap          : {acc_t - baseline_t:+.4f}")

print("The same model, with other metrics:")
b = model_t.predict(Xt_te)
print(f"  Accuracy : {accuracy_score(yt_te, b):.4f}   (baseline {baseline_t:.4f}, so little gain)")
print(f"  F1       : {f1_score(yt_te, b):.4f}")
from sklearn.metrics import recall_score, precision_score
print(f"  Precision: {precision_score(yt_te, b, zero_division=0):.4f}")
print(f"  Recall   : {recall_score(yt_te, b, zero_division=0):.4f}")

from sklearn.dummy import DummyRegressor
from sklearn.linear_model import Ridge
from sklearn.metrics import root_mean_squared_error, r2_score

yn = df["narx_usd"]
Xn_tr, Xn_te, yn_tr, yn_te = train_test_split(X, yn, test_size=0.3, random_state=42)

d_reg = DummyRegressor(strategy="mean").fit(Xn_tr[num], yn_tr)
rmse_baseline = root_mean_squared_error(yn_te, d_reg.predict(Xn_te[num]))

pipe_reg = Pipeline([
    ("prep", ColumnTransformer([
        ("num", Pipeline([("impute", SimpleImputer(strategy="median")),
                          ("scale", StandardScaler())]), num),
        ("cat", OneHotEncoder(handle_unknown="ignore"), ["tuman"]),
    ])),
    ("model", Ridge()),
]).fit(Xn_tr, yn_tr)
pred_reg = pipe_reg.predict(Xn_te)

print(f"BASELINE (always the mean): RMSE = {rmse_baseline:.1f}  R2 = {r2_score(yn_te, d_reg.predict(Xn_te[num])):.4f}")
print(f"MODEL (Ridge)             : RMSE = {root_mean_squared_error(yn_te, pred_reg):.1f}  R2 = {r2_score(yn_te, pred_reg):.4f}")

show(pd.DataFrame([
    {"Baseline": "Dummy (most_frequent)", "What it shows": "Whether the model learned anything at all",
     "Who asks": "You"},
    {"Baseline": "A simple rule (if price < X)", "What it shows": "Whether ML's complexity is needed",
     "Who asks": "A senior engineer"},
    {"Baseline": "The current process (a person/old system)", "What it shows": "Whether the project pays off",
     "Who asks": "The manager: the most important question"},
]))

import numpy as np
cutoff = X_tr["maydon_m2"].median()
rule = (X_te["maydon_m2"] < cutoff).astype(int)   # a guess that smaller flats go faster
print(f"Rule: if area < {cutoff:.0f} m2, 'goes fast'")
print(f"  Accuracy: {accuracy_score(y_te, rule):.4f}")
print(f"  F1      : {f1_score(y_te, rule, zero_division=0):.4f}")
print()
print(f"Comparison -> dummy {baseline:.4f} | rule {accuracy_score(y_te, rule):.4f} | model {model_acc:.4f}")

show(pd.DataFrame([
    {"Concept": "Why a baseline", "In one sentence": "Without it, an accuracy number means nothing"},
    {"Concept": "DummyClassifier", "In one sentence": "most_frequent is the strictest pass mark"},
    {"Concept": "DummyRegressor", "In one sentence": "Always the mean; that is the point where R2=0"},
    {"Concept": "A high baseline", "In one sentence": "Above 0.85, drop accuracy and move to F1"},
    {"Concept": "The simple-rule baseline", "In one sentence": "Answers whether you need ML at all"},
    {"Concept": "The business baseline", "In one sentence": "Who does this now, and how well"},
]))