Eight modules: metrics and charts first, notebooks on demand.

# Skill demo — reusable sklearn pipeline (synthetic)
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

prep = ColumnTransformer([
    ("num", StandardScaler(), ["temp", "humidity", "wind"]),
    ("cat", OneHotEncoder(handle_unknown="ignore"), ["zone"]),
])
clf = Pipeline([
    ("prep", prep),
    ("model", LogisticRegression(max_iter=2000)),
])
scores = cross_val_score(clf, X, y, cv=5, scoring="f1")
print(scores.mean().round(3), scores.std().round(3))

# Skill demo — seaborn + plotly pattern (synthetic ops series)
import seaborn as sns
import plotly.express as px

sns.set_theme(style="whitegrid")
ax = sns.lineplot(data=df, x="hour", y="otif", hue="region")
ax.set_title("OTIF by hour — GTA corridors")

fig = px.scatter(df, x="freight_cost", y="fill_rate",
                 color="exception", hover_data=["plant"],
                 title="Cost vs fill — exception overlay")
fig.show()

# Skill demo — A/B conversion test + holdout classifier
from scipy import stats
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score
from sklearn.linear_model import LogisticRegression

t_stat, p_val = stats.ttest_ind(a_conv, b_conv, equal_var=False)
print("Welch p:", round(p_val, 4))

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, stratify=y, random_state=42)
clf = LogisticRegression(max_iter=2000).fit(X_train, y_train)
auc = roc_auc_score(y_test, clf.predict_proba(X_test)[:, 1])
print("Holdout AUC:", round(auc, 3))

# Skill demo — medallion layers at demo scale (pandas stand-in for Spark)
import pandas as pd

bronze = pd.read_csv("events_raw.csv")          # append-only ingest
silver = (bronze
    .dropna(subset=["plant_id", "event_ts"])
    .assign(event_ts=lambda d: pd.to_datetime(d["event_ts"]))
    .drop_duplicates(["event_id"]))
gold = (silver
    .groupby(["plant_id", silver["event_ts"].dt.floor("D")], as_index=False)
    .agg(shipments=("event_id", "count"),
         late_rate=("is_late", "mean")))
# Spark analog: spark.read.json → filter/withColumn → groupBy.agg → parquet
gold.to_parquet("gold_plant_day.parquet")

# Skill demo — demographic parity gap on synthetic scores
import pandas as pd

def selection_rate(df, group_col, group, yhat="y_hat"):
    g = df[df[group_col] == group]
    return g[yhat].mean()

rates = {g: selection_rate(scored, "region", g)
         for g in scored["region"].unique()}
gap = max(rates.values()) - min(rates.values())
print("Selection rates:", {k: round(v, 3) for k, v in rates.items()})
print("Parity gap:", round(gap, 3))
# Document threshold, protected attributes, and mitigation owner in model card

# Skill demo — synthetic posts → TF-IDF topics + lexicon polarity
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import NMF

pos = {"fast", "great", "love"}; neg = {"late", "broken", "angry"}
def polarity(text):
    toks = set(text.lower().split())
    return (len(toks & pos) - len(toks & neg)) / max(len(toks), 1)

posts["score"] = posts["text"].map(polarity)
vec = TfidfVectorizer(max_features=500, stop_words="english")
X = vec.fit_transform(posts["text"])
nmf = NMF(n_components=4, random_state=0).fit(X)
terms = vec.get_feature_names_out()
for i, comp in enumerate(nmf.components_):
    top = terms[comp.argsort()[-5:][::-1]]
    print(f"Topic {i}:", ", ".join(top))

# Skill demo — tiny PyTorch MLP (XOR-style non-linearity)
import torch
import torch.nn as nn

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(2, 16), nn.ReLU(),
            nn.Linear(16, 1),
        )
    def forward(self, x):
        return self.net(x).squeeze(-1)

model = MLP()
opt = torch.optim.Adam(model.parameters(), lr=1e-2)
loss_fn = nn.BCEWithLogitsLoss()
for _ in range(400):
    opt.zero_grad()
    loss = loss_fn(model(X), y)
    loss.backward(); opt.step()
print("final loss", float(loss))

# Skill demo — text → vectors → intent classifier (synthetic tickets)
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import LinearSVC
from sklearn.pipeline import make_pipeline
from sklearn.metrics import classification_report

pipe = make_pipeline(
    TfidfVectorizer(ngram_range=(1, 2), min_df=2),
    LinearSVC(),
)
pipe.fit(train_text, train_label)
print(classification_report(test_label, pipe.predict(test_text)))

# Transformer sketch (deployment path):
# from transformers import pipeline
# ner = pipeline("ner", aggregation_strategy="simple")
# ner("Delay at Milton DC for PO-4412")