Visualization — ROC Perfection Hid 3-Week Fraud Failure

import matplotlib.pyplot as plt
import numpy as np


# --- Method 1: pyplot interface (quick exploration only) ---
# Implicitly creates a Figure and Axes. Fine for throwaway cells.
plt.plot([1, 2, 3], [4, 5, 6])
plt.title('Simple Line Plot')
plt.xlabel('X Axis')
plt.ylabel('Y Axis')
plt.show()


# --- Method 2: object-oriented interface (production standard) ---
# Explicitly creates Figure and Axes. Use this for everything you save.
fig, ax = plt.subplots(figsize=(10, 6))

ax.plot([1, 2, 3], [4, 5, 6], marker='o', linewidth=2, label='Series A')
ax.set_title('Production-Ready Line Plot', fontsize=14, fontweight='bold')
ax.set_xlabel('X Axis')
ax.set_ylabel('Y Axis')
ax.legend()
ax.grid(True, alpha=0.3)

fig.tight_layout()
fig.savefig('plot.png', dpi=300, bbox_inches='tight')
plt.close(fig)  # Free memory — critical in loops and pipelines


# --- Multi-panel figure: the pattern you will use most ---
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
np.random.seed(42)
data = np.random.randn(200)

# Panel 1: Distribution
axes[0, 0].hist(data, bins=30, edgecolor='black', alpha=0.7, color='steelblue')
axes[0, 0].set_title('Distribution')
axes[0, 0].set_xlabel('Value')
axes[0, 0].set_ylabel('Frequency')

# Panel 2: Sequential scatter
axes[0, 1].scatter(np.arange(len(data)), data, alpha=0.4, s=12, color='coral')
axes[0, 1].axhline(y=0, color='black', linestyle='--', alpha=0.3)
axes[0, 1].set_title('Sequential Scatter')
axes[0, 1].set_xlabel('Index')

# Panel 3: Box plot
axes[1, 0].boxplot(data, vert=True, patch_artist=True,
                    boxprops=dict(facecolor='lightblue'))
axes[1, 0].set_title('Box Plot')

# Panel 4: Cumulative sum
axes[1, 1].plot(np.cumsum(data), color='seagreen', linewidth=1.5)
axes[1, 1].set_title('Cumulative Sum')
axes[1, 1].set_xlabel('Index')

fig.suptitle('Exploratory Data Summary', fontsize=16, fontweight='bold')
fig.tight_layout()
fig.savefig('dashboard.png', dpi=300, bbox_inches='tight')
plt.close(fig)

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np


# Set Seaborn theme once at the top of your notebook or script
sns.set_theme(style='whitegrid', palette='muted', font_scale=1.1)

# Generate example data
np.random.seed(42)
df = pd.DataFrame({
    'feature_a': np.random.randn(200),
    'feature_b': np.random.randn(200) * 2 + 1,
    'category': np.random.choice(['Class A', 'Class B', 'Class C'], 200),
    'target': np.random.choice([0, 1], 200)
})


# --- Distribution plots: understand feature spread ---
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

sns.histplot(data=df, x='feature_a', hue='category', kde=True, ax=axes[0])
axes[0].set_title('Feature A Distribution by Category')

sns.boxplot(data=df, x='category', y='feature_b', ax=axes[1])
axes[1].set_title('Feature B Spread by Category')

fig.tight_layout()
fig.savefig('distributions.png', dpi=300, bbox_inches='tight')
plt.close(fig)


# --- Correlation heatmap: find feature relationships ---
fig, ax = plt.subplots(figsize=(8, 6))
numeric_df = df.select_dtypes(include=[np.number])
corr_matrix = numeric_df.corr()

sns.heatmap(
    corr_matrix, annot=True, fmt='.2f', cmap='RdBu_r',
    center=0, vmin=-1, vmax=1, ax=ax,
    linewidths=0.5, square=True
)
ax.set_title('Feature Correlation Matrix')

fig.tight_layout()
fig.savefig('correlation.png', dpi=300, bbox_inches='tight')
plt.close(fig)


# --- Pair plot: explore all pairwise relationships at once ---
# Useful for small feature sets (<10 features). Slow for large ones.
pair = sns.pairplot(
    df, hue='category', diag_kind='kde',
    plot_kws={'alpha': 0.4, 's': 15}
)
pair.figure.suptitle('Pairwise Feature Relationships', y=1.02)
pair.savefig('pairplot.png', dpi=150, bbox_inches='tight')
plt.close('all')


# --- Seaborn + Matplotlib customization: the practical pattern ---
fig, ax = plt.subplots(figsize=(10, 6))
sns.violinplot(data=df, x='category', y='feature_a', ax=ax, inner='quartile')

# Drop down to Matplotlib for fine-tuning
ax.set_title('Feature A Violin Plot', fontsize=14, fontweight='bold')
ax.set_xlabel('Category', fontsize=12)
ax.set_ylabel('Feature A Value', fontsize=12)
ax.axhline(y=0, color='red', linestyle='--', alpha=0.5, label='Zero baseline')
ax.legend()

fig.tight_layout()
fig.savefig('violin_customized.png', dpi=300, bbox_inches='tight')
plt.close(fig)

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
from sklearn.metrics import confusion_matrix


def plot_confusion_matrix(
    y_true, y_pred, labels=None, title='Confusion Matrix'
):
    """Production-grade confusion matrix with both counts and percentages.

    Displays two panels side by side:
    - Left: raw counts (useful for understanding volume)
    - Right: row-normalized percentages (useful for understanding recall per class)

    Args:
        y_true: ground truth labels
        y_pred: predicted labels
        labels: list of class names for axis labels
        title: figure title

    Returns:
        Matplotlib Figure object (caller saves and closes).
    """
    cm = confusion_matrix(y_true, y_pred)
    cm_percent = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] * 100

    fig, axes = plt.subplots(1, 2, figsize=(14, 5))

    # Left panel: raw counts
    sns.heatmap(
        cm, annot=True, fmt='d', cmap='Blues',
        xticklabels=labels, yticklabels=labels,
        ax=axes[0], linewidths=0.5
    )
    axes[0].set_xlabel('Predicted')
    axes[0].set_ylabel('Actual')
    axes[0].set_title(f'{title} (Counts)')

    # Right panel: row-normalized percentages (each row sums to 100%)
    sns.heatmap(
        cm_percent, annot=True, fmt='.1f', cmap='Blues',
        xticklabels=labels, yticklabels=labels,
        ax=axes[1], linewidths=0.5, vmin=0, vmax=100
    )
    axes[1].set_xlabel('Predicted')
    axes[1].set_ylabel('Actual')
    axes[1].set_title(f'{title} (Row %, i.e., Recall)')

    fig.tight_layout()
    return fig


# Example usage
np.random.seed(42)
y_true = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2] * 20)
y_pred = np.array([0, 0, 1, 1, 1, 0, 2, 2, 2] * 20)
labels = ['Cat', 'Dog', 'Bird']

fig = plot_confusion_matrix(y_true, y_pred, labels=labels, title='Animal Classifier')
fig.savefig('confusion_matrix.png', dpi=300, bbox_inches='tight')
plt.close(fig)

import matplotlib.pyplot as plt
import numpy as np
from sklearn.metrics import (
    roc_curve, auc, precision_recall_curve, average_precision_score
)


def plot_roc_and_pr(y_true, y_proba, title='Model Evaluation'):
    """Plot ROC and Precision-Recall curves side by side.

    Both curves visualize model performance across all possible
    classification thresholds. Together they give a complete picture
    that no single metric can provide.

    Args:
        y_true: ground truth binary labels (0 or 1)
        y_proba: predicted probabilities for the positive class
        title: figure title prefix

    Returns:
        Matplotlib Figure object.
    """
    # Compute ROC curve
    fpr, tpr, roc_thresholds = roc_curve(y_true, y_proba)
    roc_auc = auc(fpr, tpr)

    # Compute Precision-Recall curve
    precision, recall, pr_thresholds = precision_recall_curve(y_true, y_proba)
    avg_precision = average_precision_score(y_true, y_proba)

    fig, axes = plt.subplots(1, 2, figsize=(14, 6))

    # --- ROC Curve ---
    axes[0].plot(fpr, tpr, linewidth=2, label=f'Model (AUC = {roc_auc:.3f})')
    axes[0].plot([0, 1], [0, 1], 'k--', alpha=0.5, label='Random (AUC = 0.5)')
    axes[0].fill_between(fpr, tpr, alpha=0.1)
    axes[0].set_xlabel('False Positive Rate')
    axes[0].set_ylabel('True Positive Rate (Recall)')
    axes[0].set_title(f'{title} — ROC Curve')
    axes[0].legend(loc='lower right')
    axes[0].grid(True, alpha=0.3)
    axes[0].set_xlim([-0.02, 1.02])
    axes[0].set_ylim([-0.02, 1.02])

    # --- Precision-Recall Curve ---
    axes[1].plot(
        recall, precision, linewidth=2, color='orange',
        label=f'Model (AP = {avg_precision:.3f})'
    )
    baseline = y_true.sum() / len(y_true)
    axes[1].axhline(
        y=baseline, color='k', linestyle='--', alpha=0.5,
        label=f'Random baseline = {baseline:.3f}'
    )
    axes[1].fill_between(recall, precision, alpha=0.1, color='orange')
    axes[1].set_xlabel('Recall')
    axes[1].set_ylabel('Precision')
    axes[1].set_title(f'{title} — Precision-Recall Curve')
    axes[1].legend(loc='lower left')
    axes[1].grid(True, alpha=0.3)
    axes[1].set_xlim([-0.02, 1.02])
    axes[1].set_ylim([0, 1.05])

    fig.tight_layout()
    return fig


# Example: imbalanced fraud detection scenario
np.random.seed(42)
y_true = np.random.choice([0, 1], size=500, p=[0.95, 0.05])
y_proba = np.clip(y_true * 0.6 + np.random.randn(500) * 0.2, 0, 1)

fig = plot_roc_and_pr(y_true, y_proba, title='Fraud Detection')
fig.savefig('roc_pr_curves.png', dpi=300, bbox_inches='tight')
plt.close(fig)

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
from scipy import stats
from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression


def plot_regression_diagnostics(y_true, y_pred, title='Regression Diagnostics'):
    """Four-panel diagnostic plot for regression models.

    Panels:
    1. Predicted vs Actual — overall fit quality
    2. Residuals vs Predicted — detect non-linearity, heteroscedasticity
    3. Residual Distribution — check normality assumption
    4. Q-Q Plot — sensitive normality check at distribution tails

    Args:
        y_true: actual target values (numpy array)
        y_pred: predicted target values (numpy array)
        title: overall figure title

    Returns:
        Matplotlib Figure object.
    """
    residuals = y_true - y_pred

    fig, axes = plt.subplots(2, 2, figsize=(14, 10))

    # Panel 1: Predicted vs Actual
    axes[0, 0].scatter(y_true, y_pred, alpha=0.4, s=15, color='steelblue')
    min_val = min(y_true.min(), y_pred.min())
    max_val = max(y_true.max(), y_pred.max())
    axes[0, 0].plot(
        [min_val, max_val], [min_val, max_val],
        'r--', linewidth=2, label='Perfect prediction'
    )
    axes[0, 0].set_xlabel('Actual')
    axes[0, 0].set_ylabel('Predicted')
    axes[0, 0].set_title('Predicted vs Actual')
    axes[0, 0].legend()

    # Panel 2: Residuals vs Predicted (the most important panel)
    axes[0, 1].scatter(y_pred, residuals, alpha=0.4, s=15, color='coral')
    axes[0, 1].axhline(y=0, color='r', linestyle='--', linewidth=2)
    axes[0, 1].set_xlabel('Predicted Value')
    axes[0, 1].set_ylabel('Residual (Actual - Predicted)')
    axes[0, 1].set_title('Residuals vs Predicted')

    # Panel 3: Residual Distribution
    sns.histplot(residuals, kde=True, ax=axes[1, 0], bins=30, color='steelblue')
    axes[1, 0].axvline(x=0, color='r', linestyle='--')
    axes[1, 0].set_xlabel('Residual')
    axes[1, 0].set_title(f'Residual Distribution (mean={residuals.mean():.2f})')

    # Panel 4: Q-Q plot (normality check — deviations at tails matter most)
    stats.probplot(residuals, dist='norm', plot=axes[1, 1])
    axes[1, 1].set_title('Q-Q Plot (Normality Check)')

    fig.suptitle(title, fontsize=14, fontweight='bold')
    fig.tight_layout()
    return fig


# Example
X, y = make_regression(
    n_samples=300, n_features=3, noise=15, random_state=42
)
model = LinearRegression().fit(X, y)
y_pred = model.predict(X)

fig = plot_regression_diagnostics(y, y_pred, title='Linear Regression Diagnostics')
fig.savefig('residual_plots.png', dpi=300, bbox_inches='tight')
plt.close(fig)

import matplotlib.pyplot as plt
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.inspection import permutation_importance
from sklearn.datasets import make_classification


def plot_feature_importance(
    model, feature_names, X_test, y_test, top_n=15
):
    """Plot built-in and permutation importance side by side.

    Built-in importance (Gini) is fast but biased toward high-cardinality
    features. Permutation importance is slower but model-agnostic and
    unbiased. Showing both highlights discrepancies worth investigating.

    Args:
        model: fitted sklearn estimator
        feature_names: list of feature name strings
        X_test: test features for permutation importance
        y_test: test labels for permutation importance
        top_n: number of top features to display

    Returns:
        Matplotlib Figure object.
    """
    fig, axes = plt.subplots(1, 2, figsize=(14, max(6, top_n * 0.4)))

    # Left panel: built-in importance (tree-based models only)
    if hasattr(model, 'feature_importances_'):
        importances = model.feature_importances_
        indices = np.argsort(importances)[::-1][:top_n]

        axes[0].barh(
            [feature_names[i] for i in indices][::-1],
            importances[indices][::-1],
            color='steelblue', edgecolor='black', alpha=0.8
        )
        axes[0].set_xlabel('Gini Importance (Impurity Reduction)')
        axes[0].set_title('Built-in Feature Importance')
    else:
        axes[0].text(
            0.5, 0.5, 'Not available\n(model has no feature_importances_)',
            ha='center', va='center', fontsize=12, transform=axes[0].transAxes
        )
        axes[0].set_title('Built-in Feature Importance (N/A)')

    # Right panel: permutation importance (model-agnostic)
    perm_result = permutation_importance(
        model, X_test, y_test, n_repeats=10, random_state=42, n_jobs=-1
    )
    perm_mean = perm_result.importances_mean
    perm_std = perm_result.importances_std
    indices = np.argsort(perm_mean)[::-1][:top_n]

    axes[1].barh(
        [feature_names[i] for i in indices][::-1],
        perm_mean[indices][::-1],
        xerr=perm_std[indices][::-1],
        color='coral', edgecolor='black', alpha=0.8
    )
    axes[1].set_xlabel('Mean Accuracy Decrease When Shuffled')
    axes[1].set_title('Permutation Importance')

    fig.suptitle(
        'Feature Importance Comparison', fontsize=14, fontweight='bold'
    )
    fig.tight_layout()
    return fig


# Example
X, y = make_classification(
    n_samples=1000, n_features=10, n_informative=5, random_state=42
)
feature_names = [f'feature_{i}' for i in range(10)]
model = RandomForestClassifier(
    n_estimators=100, random_state=42
).fit(X, y)

fig = plot_feature_importance(model, feature_names, X, y)
fig.savefig('feature_importance.png', dpi=300, bbox_inches='tight')
plt.close(fig)

import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import learning_curve
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification


def plot_learning_curve(
    estimator, X, y, title='Learning Curve', cv=5, scoring='accuracy'
):
    """Plot learning curve showing the bias-variance tradeoff.

    The gap between training and validation curves tells you exactly
    what to fix: more data, more regularization, or a different model.

    Args:
        estimator: unfitted sklearn estimator (will be cloned internally)
        X: feature matrix
        y: target vector
        title: plot title
        cv: number of cross-validation folds
        scoring: sklearn scoring metric name

    Returns:
        Matplotlib Figure object.
    """
    train_sizes, train_scores, val_scores = learning_curve(
        estimator, X, y,
        cv=cv,
        n_jobs=-1,
        train_sizes=np.linspace(0.1, 1.0, 10),
        scoring=scoring
    )

    train_mean = train_scores.mean(axis=1)
    train_std = train_scores.std(axis=1)
    val_mean = val_scores.mean(axis=1)
    val_std = val_scores.std(axis=1)

    fig, ax = plt.subplots(figsize=(10, 6))

    # Confidence bands
    ax.fill_between(
        train_sizes, train_mean - train_std, train_mean + train_std,
        alpha=0.1, color='blue'
    )
    ax.fill_between(
        train_sizes, val_mean - val_std, val_mean + val_std,
        alpha=0.1, color='orange'
    )

    # Mean curves
    ax.plot(
        train_sizes, train_mean, 'o-', color='blue',
        linewidth=2, label='Training Score'
    )
    ax.plot(
        train_sizes, val_mean, 'o-', color='orange',
        linewidth=2, label='Validation Score'
    )

    ax.set_xlabel('Training Set Size')
    ax.set_ylabel(scoring.capitalize())
    ax.set_title(title, fontsize=14, fontweight='bold')
    ax.legend(loc='lower right')
    ax.grid(True, alpha=0.3)

    # Annotate the final gap between curves
    final_gap = train_mean[-1] - val_mean[-1]
    ax.annotate(
        f'Gap: {final_gap:.3f}',
        xy=(train_sizes[-1], (train_mean[-1] + val_mean[-1]) / 2),
        fontsize=11, fontweight='bold', color='red',
        ha='right'
    )

    fig.tight_layout()
    return fig


# Example
X, y = make_classification(
    n_samples=1000, n_features=20, n_informative=10, random_state=42
)
model = RandomForestClassifier(n_estimators=100, random_state=42)

fig = plot_learning_curve(model, X, y, title='Random Forest Learning Curve')
fig.savefig('learning_curve.png', dpi=300, bbox_inches='tight')
plt.close(fig)

import matplotlib.pyplot as plt
import matplotlib as mpl
import numpy as np


def apply_production_style():
    """Apply a consistent, publication-quality style globally.

    Call this once at the top of your notebook or script.
    Overrides Matplotlib defaults with production-safe values.
    """
    mpl.rcParams.update({
        # Typography
        'font.size': 12,
        'axes.titlesize': 14,
        'axes.labelsize': 12,
        'xtick.labelsize': 10,
        'ytick.labelsize': 10,
        'legend.fontsize': 10,
        'figure.titlesize': 16,

        # Figure defaults
        'figure.figsize': (10, 6),
        'figure.dpi': 100,           # Screen display DPI
        'savefig.dpi': 300,          # Saved file DPI
        'savefig.bbox': 'tight',     # Prevent label clipping
        'savefig.pad_inches': 0.1,

        # Grid and spines
        'axes.grid': True,
        'grid.alpha': 0.3,
        'axes.spines.top': False,    # Remove top spine
        'axes.spines.right': False,  # Remove right spine

        # Lines and markers
        'lines.linewidth': 2,
        'lines.markersize': 6,
    })
    print("Production style applied.")


def save_publication(fig, filename, formats=None):
    """Save figure in multiple formats for different use cases.

    Args:
        fig: Matplotlib Figure object
        filename: base filename without extension
        formats: list of format strings. Defaults to PNG + SVG.
    """
    if formats is None:
        formats = ['png', 'svg']

    for fmt in formats:
        filepath = f"{filename}.{fmt}"
        fig.savefig(filepath, dpi=300, bbox_inches='tight', facecolor='white')
        print(f"Saved: {filepath}")


# --- Usage ---
apply_production_style()

fig, ax = plt.subplots()
colors = ['#2563eb', '#16a34a', '#dc2626']  # Blue, green, red — distinguishable
ax.bar(
    ['Model A', 'Model B', 'Model C'],
    [0.89, 0.92, 0.87],
    color=colors, edgecolor='black', alpha=0.9
)
ax.set_ylabel('Accuracy')
ax.set_title('Model Comparison — Q1 2026')
ax.set_ylim(0.80, 0.95)

# Add value labels on bars
for i, v in enumerate([0.89, 0.92, 0.87]):
    ax.text(i, v + 0.003, f'{v:.2f}', ha='center', fontweight='bold')

save_publication(fig, 'model_comparison')
plt.close(fig)

import shap
import xgboost as xgb
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

X, y = load_breast_cancer(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = xgb.XGBClassifier()
model.fit(X_train, y_train)

explainer = shap.Explainer(model, X_train)
shap_values = explainer(X_test)

shap.summary_plot(shap_values, X_test)

import lime.lime_tabular
import xgboost as xgb
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

X, y = load_breast_cancer(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = xgb.XGBClassifier()
model.fit(X_train, y_train)

explainer = lime.lime_tabular.LimeTabularExplainer(
    X_train.values, training_labels=y_train.values, feature_names=X_train.columns.tolist(),
    class_names=['benign', 'malignant'], mode='classification'
)

exp = explainer.explain_instance(X_test.iloc[0].values, model.predict_proba, num_features=5)
exp.show_in_notebook(show_table=True)