PyTorch vs Old Tools — What Changed for QA Testers

# QA testing a PyTorch model's accuracy
# (You do not need to be an ML engineer to write this.)

import torch
from sklearn.metrics import precision_score, recall_score, f1_score

def test_model_meets_accuracy_threshold():
    """Model must maintain precision above 0.80 on the test set."""
    model = torch.load("models/churn_v3.pt")
    model.eval()

    X_test, y_test = load_test_set()  # from your test data loader

    with torch.no_grad():
        outputs = model(X_test)
        preds = outputs.argmax(dim=1)

    precision = precision_score(y_test, preds, average="macro")
    recall = recall_score(y_test, preds, average="macro")
    f1 = f1_score(y_test, preds, average="macro")

    # QA threshold — defined by the business, not by the ML team
    assert precision >= 0.80, f"Precision dropped to {precision:.3f}"
    assert recall >= 0.70, f"Recall dropped to {recall:.3f}"
    assert f1 >= 0.75, f"F1 dropped to {f1:.3f}"

    print(f"PASS — P={precision:.3f}, R={recall:.3f}, F1={f1:.3f}")

# What this proves in a QA interview:
# - You can read a PyTorch model and run inference
# - You understand the metrics that matter (not just accuracy)
# - You set QA thresholds, not ML thresholds
# - You can explain what a "regression" means for a model

# This is the exact kind of test modern QA teams are
# writing — a test that guards against model regression.

# QA testing for data drift — the test old tools
# simply could not do.

import pandas as pd
from scipy.stats import ks_2samp

def test_feature_distribution_not_drifted():
    """Key features should not have drifted significantly from
    the training distribution."""
    train = pd.read_csv("data/train_snapshot.csv")
    live = pd.read_csv("data/last_week_live.csv")

    drifted_features = []
    for col in ["tenure_months", "monthly_spend", "support_tickets"]:
        stat, p_value = ks_2samp(train[col], live[col])
        # p < 0.05 means distributions differ significantly
        if p_value < 0.05:
            drifted_features.append((col, p_value))

    assert not drifted_features, (
        f"Data drift detected in: {drifted_features}"
    )

    print("PASS — no significant drift detected")

# What this proves in a QA interview:
# - You understand that data is part of the system
# - You know a real drift test (KS test), not just a vibe check
# - You can distinguish model bugs from data bugs
# - You can explain to a PM why the model is underperforming

# Old QA tools could not catch this. The model "works"
# — the data around it has changed.

# QA testing for data quality — a basic but
# critical test that catches the majority of
# production model issues.

import pandas as pd

def test_input_data_quality():
    """Basic data contract checks before the model runs."""
    df = pd.read_csv("data/production_input.csv")

    # 1. No missing critical fields
    critical_cols = ["customer_id", "tenure_months", "monthly_spend"]
    null_counts = df[critical_cols].isna().sum()
    assert null_counts.sum() == 0, f"Nulls in critical cols: {null_counts}"

    # 2. Values within expected ranges
    assert df["tenure_months"].between(0, 120).all(), "tenure out of range"
    assert df["monthly_spend"].between(0, 100000).all(), "spend out of range"

    # 3. No duplicate customer records
    duplicates = df["customer_id"].duplicated().sum()
    assert duplicates == 0, f"{duplicates} duplicate customer_ids"

    # 4. Expected categories only
    valid_plans = {"basic", "standard", "premium"}
    invalid_plans = set(df["plan"].unique()) - valid_plans
    assert not invalid_plans, f"Unknown plans: {invalid_plans}"

    print("PASS — input data quality checks succeeded")

# What this proves in a QA interview:
# - You know data quality is a QA responsibility
# - You can write tests that catch the most common
#   production issues (nulls, ranges, dupes, enums)
# - You can add these to a CI/CD pipeline alongside
#   Selenium and API tests
# - You understand that a model cannot be reliable
#   if its input data is not

# This is the most underrated QA skill of the PyTorch era.