Machine Learning Interview Questions

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import PolynomialFeatures

# High Bias Model (Underfitting)
linear_model = LinearRegression()
scores_linear = cross_val_score(linear_model, X, y, cv=5)
print(f"Linear Model CV Score: {scores_linear.mean():.3f} (+/- {scores_linear.std():.3f})")

# Balanced Model
rf_model = RandomForestRegressor(n_estimators=100, max_depth=10)
scores_rf = cross_val_score(rf_model, X, y, cv=5)
print(f"Random Forest CV Score: {scores_rf.mean():.3f} (+/- {scores_rf.std():.3f})")

# High Variance Model (Overfitting risk)
rf_deep = RandomForestRegressor(n_estimators=500, max_depth=None, min_samples_leaf=1)
scores_deep = cross_val_score(rf_deep, X, y, cv=5)
print(f"Deep RF CV Score: {scores_deep.mean():.3f} (+/- {scores_deep.std():.3f})")

from sklearn.linear_model import Lasso, Ridge, ElasticNet
from sklearn.datasets import make_regression
import numpy as np

# Generate data with some irrelevant features
X, y = make_regression(n_samples=100, n_features=20, n_informative=5, noise=10)

# L1 Regularization - Feature Selection
lasso = Lasso(alpha=0.1)
lasso.fit(X, y)
print(f"L1 Non-zero coefficients: {np.sum(lasso.coef_ != 0)}/20")
# Output: ~5 (identifies informative features)

# L2 Regularization - All features kept
ridge = Ridge(alpha=0.1)
ridge.fit(X, y)
print(f"L2 Non-zero coefficients: {np.sum(ridge.coef_ != 0)}/20")
# Output: 20 (all features kept, but shrunk)

# Elastic Net - Best of both worlds
elastic = ElasticNet(alpha=0.1, l1_ratio=0.5)
elastic.fit(X, y)
print(f"Elastic Net Non-zero: {np.sum(elastic.coef_ != 0)}/20")

import torch.optim as optim

# Standard SGD
optimizer = optim.SGD(model.parameters(), lr=0.01)

# SGD with Momentum (accelerates convergence)
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# Adam (adaptive learning rates per parameter)
optimizer = optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999))

# AdamW (Adam with proper weight decay)
optimizer = optim.AdamW(model.parameters(), lr=0.001, weight_decay=0.01)

from sklearn.model_selection import (
    cross_val_score, KFold, StratifiedKFold, TimeSeriesSplit
)
from sklearn.ensemble import RandomForestClassifier

# Standard K-Fold
cv_scores = cross_val_score(
    RandomForestClassifier(),
    X, y,
    cv=5,
    scoring='accuracy'
)
print(f"CV Score: {cv_scores.mean():.3f} (+/- {cv_scores.std()*2:.3f})")

# Stratified for imbalanced data
stratified_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# Time Series (prevents data leakage)
tscv = TimeSeriesSplit(n_splits=5)
for train_idx, test_idx in tscv.split(X):
    print(f"Train: {train_idx[:3]}..., Test: {test_idx[:3]}...")

from sklearn.metrics import (
    precision_score, recall_score, f1_score,
    classification_report, precision_recall_curve
)

# All metrics at once
print(classification_report(y_true, y_pred))

# Adjust threshold for Precision-Recall tradeoff
y_proba = model.predict_proba(X_test)[:, 1]
precisions, recalls, thresholds = precision_recall_curve(y_true, y_proba)

# Find threshold for desired recall (e.g., 95%)
target_recall = 0.95
idx = np.argmin(np.abs(recalls - target_recall))
optimal_threshold = thresholds[idx]
print(f"Threshold for {target_recall} recall: {optimal_threshold:.3f}")

from sklearn.tree import DecisionTreeClassifier, plot_tree
import matplotlib.pyplot as plt

# Create and train
tree = DecisionTreeClassifier(
    max_depth=5,           # Prevent overfitting
    min_samples_split=20,  # Minimum samples to split
    min_samples_leaf=10,   # Minimum samples in leaf
    random_state=42
)
tree.fit(X_train, y_train)

# Visualize the tree
plt.figure(figsize=(20, 10))
plot_tree(tree, feature_names=feature_names, 
          class_names=class_names, filled=True)
plt.show()

# Feature importance
importance = pd.DataFrame({
    'feature': feature_names,
    'importance': tree.feature_importances_
}).sort_values('importance', ascending=False)
print(importance.head(10))

from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier

# Random Forest - Quick and robust
rf = RandomForestClassifier(
    n_estimators=100,
    max_depth=10,
    n_jobs=-1  # Parallel training
)

# Gradient Boosting (sklearn) - Good baseline
gb = GradientBoostingClassifier(
    n_estimators=100,
    learning_rate=0.1,
    max_depth=3
)

# XGBoost - Industry standard
xgb = XGBClassifier(
    n_estimators=100,
    learning_rate=0.1,
    max_depth=6,
    subsample=0.8,
    colsample_bytree=0.8,
    eval_metric='logloss'
)

# LightGBM - Fastest, handles large data
lgbm = LGBMClassifier(
    n_estimators=100,
    learning_rate=0.1,
    num_leaves=31,
    feature_fraction=0.8
)

from sklearn.model_selection import learning_curve
import matplotlib.pyplot as plt

# Diagnose overfitting with learning curves
train_sizes, train_scores, val_scores = learning_curve(
    model, X, y,
    train_sizes=np.linspace(0.1, 1.0, 10),
    cv=5,
    scoring='accuracy'
)

# Plot
plt.figure(figsize=(10, 6))
plt.plot(train_sizes, train_scores.mean(axis=1), label='Training')
plt.plot(train_sizes, val_scores.mean(axis=1), label='Validation')
plt.xlabel('Training Size')
plt.ylabel('Score')
plt.legend()
plt.title('Learning Curve - Check for Overfitting')
plt.show()

# Early stopping example (XGBoost)
from xgboost import XGBClassifier

model = XGBClassifier(
    n_estimators=1000,
    early_stopping_rounds=50,  # Stop if no improvement
    eval_metric='logloss'
)
model.fit(
    X_train, y_train,
    eval_set=[(X_val, y_val)],
    verbose=False
)
print(f"Best iteration: {model.best_iteration}")

import torch
import torch.nn as nn

class SimpleNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)  # Non-linearity is crucial!
        x = self.layer2(x)
        return x

# Training loop with backprop
model = SimpleNN(784, 256, 10)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(epochs):
    for X_batch, y_batch in dataloader:
        # Forward pass
        outputs = model(X_batch)
        loss = criterion(outputs, y_batch)

        # Backward pass (backpropagation)
        optimizer.zero_grad()  # Clear old gradients
        loss.backward()        # Compute gradients
        optimizer.step()       # Update weights

import torch.nn as nn

class DropoutNetwork(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 512)
        self.dropout1 = nn.Dropout(p=0.5)  # 50% dropout
        self.fc2 = nn.Linear(512, 256)
        self.dropout2 = nn.Dropout(p=0.3)  # 30% dropout
        self.fc3 = nn.Linear(256, 10)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.dropout1(x)  # Applied during training
        x = F.relu(self.fc2(x))
        x = self.dropout2(x)
        x = self.fc3(x)
        return x

# Important: model.eval() disables dropout for inference
model.eval()
with torch.no_grad():
    predictions = model(test_data)

# Computer Vision (PyTorch)
from torchvision import models

# Load pretrained ResNet
model = models.resnet50(pretrained=True)

# Strategy 1: Feature Extraction (freeze backbone)
for param in model.parameters():
    param.requires_grad = False

# Replace final layer for our task
model.fc = nn.Linear(model.fc.in_features, num_classes)

# Strategy 2: Fine-tuning (unfreeze last block)
for param in model.layer4.parameters():
    param.requires_grad = True

# NLP (Hugging Face Transformers)
from transformers import AutoModelForSequenceClassification, AutoTokenizer

# Load pretrained BERT
model = AutoModelForSequenceClassification.from_pretrained(
    'bert-base-uncased',
    num_labels=2  # Binary classification
)
tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')

# Fine-tune with lower learning rate for pretrained layers
optimizer = AdamW([
    {'params': model.bert.parameters(), 'lr': 2e-5},     # Pretrained
    {'params': model.classifier.parameters(), 'lr': 1e-4}  # New head
])

from sklearn.metrics import roc_curve, auc, roc_auc_score
import matplotlib.pyplot as plt

# Get probabilities
y_proba = model.predict_proba(X_test)[:, 1]

# Calculate ROC curve
fpr, tpr, thresholds = roc_curve(y_test, y_proba)
roc_auc = auc(fpr, tpr)

# Plot
plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='blue', label=f'ROC Curve (AUC = {roc_auc:.3f})')
plt.plot([0, 1], [0, 1], color='gray', linestyle='--', label='Random')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.legend()
plt.show()

# Quick AUC calculation
print(f"AUC Score: {roc_auc_score(y_test, y_proba):.3f}")

# Find optimal threshold (Youden's J statistic)
optimal_idx = np.argmax(tpr - fpr)
optimal_threshold = thresholds[optimal_idx]
print(f"Optimal Threshold: {optimal_threshold:.3f}")

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# Step 1: Always scale before PCA!
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Step 2: Determine optimal number of components
pca_full = PCA()
pca_full.fit(X_scaled)

# Plot explained variance
cumsum = np.cumsum(pca_full.explained_variance_ratio_)
n_95 = np.argmax(cumsum >= 0.95) + 1
print(f"Components for 95% variance: {n_95}")

# Step 3: Apply PCA
pca = PCA(n_components=n_95)
X_reduced = pca.fit_transform(X_scaled)

# Visualization (2D)
pca_2d = PCA(n_components=2)
X_2d = pca_2d.fit_transform(X_scaled)
plt.scatter(X_2d[:, 0], X_2d[:, 1], c=y, cmap='viridis')
plt.xlabel(f'PC1 ({pca_2d.explained_variance_ratio_[0]:.1%} var)')
plt.ylabel(f'PC2 ({pca_2d.explained_variance_ratio_[1]:.1%} var)')
plt.show()

from sklearn.utils.class_weight import compute_class_weight
from imblearn.over_sampling import SMOTE
from imblearn.under_sampling import RandomUnderSampler
from imblearn.pipeline import Pipeline

# Method 1: Class Weights (built into most algorithms)
class_weights = compute_class_weight('balanced', classes=np.unique(y), y=y)
model = RandomForestClassifier(class_weight='balanced')

# Method 2: SMOTE (Synthetic Minority Over-sampling)
smote = SMOTE(sampling_strategy=0.5, random_state=42)
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)

# Method 3: Combined Sampling Pipeline
pipeline = Pipeline([
    ('under', RandomUnderSampler(sampling_strategy=0.5)),
    ('over', SMOTE(sampling_strategy=1.0)),
])
X_balanced, y_balanced = pipeline.fit_resample(X_train, y_train)

# Method 4: Threshold Tuning
y_proba = model.predict_proba(X_test)[:, 1]
# Lower threshold to catch more positives
y_pred_adjusted = (y_proba >= 0.3).astype(int)  # Instead of 0.5

# Method 5: Focal Loss (PyTorch)
class FocalLoss(nn.Module):
    def __init__(self, alpha=0.25, gamma=2):
        super().__init__()
        self.alpha = alpha
        self.gamma = gamma

    def forward(self, inputs, targets):
        ce_loss = F.cross_entropy(inputs, targets, reduction='none')
        pt = torch.exp(-ce_loss)
        focal_loss = self.alpha * (1 - pt) ** self.gamma * ce_loss
        return focal_loss.mean()

from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
import matplotlib.pyplot as plt

# Elbow Method
inertias = []
silhouettes = []
K_range = range(2, 11)

for k in K_range:
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
    kmeans.fit(X)
    inertias.append(kmeans.inertia_)
    silhouettes.append(silhouette_score(X, kmeans.labels_))

# Plot
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))

ax1.plot(K_range, inertias, 'bo-')
ax1.set_xlabel('Number of Clusters (K)')
ax1.set_ylabel('Inertia')
ax1.set_title('Elbow Method')

ax2.plot(K_range, silhouettes, 'ro-')
ax2.set_xlabel('Number of Clusters (K)')
ax2.set_ylabel('Silhouette Score')
ax2.set_title('Silhouette Method')
plt.show()

# Final model
optimal_k = 5  # From elbow analysis
kmeans = KMeans(n_clusters=optimal_k, random_state=42, n_init=10)
labels = kmeans.fit_predict(X)

from sklearn.svm import SVC

# Linear kernel - for linearly separable data
svm_linear = SVC(kernel='linear', C=1.0)

# RBF (Gaussian) - most common for non-linear
svm_rbf = SVC(kernel='rbf', gamma='scale', C=1.0)

# Polynomial kernel
svm_poly = SVC(kernel='poly', degree=3, C=1.0)

# Training
svm_rbf.fit(X_train, y_train)
predictions = svm_rbf.predict(X_test)

import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        # Input: 3 channels (RGB), Output: 32 filters, 3x3 kernel
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)  # 2x2 pooling
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.fc1 = nn.Linear(64 * 8 * 8, 256)  # After 2 pools: 32→16→8
        self.fc2 = nn.Linear(256, 10)  # 10 classes

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))  # 32x32 → 16x16
        x = self.pool(F.relu(self.conv2(x)))  # 16x16 → 8x8
        x = x.view(-1, 64 * 8 * 8)  # Flatten
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

import torch.nn as nn

class LSTMModel(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, output_dim):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.lstm = nn.LSTM(embed_dim, hidden_dim, 
                           num_layers=2, dropout=0.5, 
                           batch_first=True, bidirectional=True)
        self.fc = nn.Linear(hidden_dim * 2, output_dim)  # *2 for bidirectional

    def forward(self, x):
        embedded = self.embedding(x)
        output, (hidden, cell) = self.lstm(embedded)
        # Concatenate final hidden states from both directions
        hidden = torch.cat((hidden[-2], hidden[-1]), dim=1)
        return self.fc(hidden)

import torch.nn as nn

class CNNWithBatchNorm(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 64, 3, padding=1)
        self.bn1 = nn.BatchNorm2d(64)  # After conv, before activation
        self.relu = nn.ReLU()

        self.fc = nn.Linear(64 * 32 * 32, 10)
        self.bn_fc = nn.BatchNorm1d(10)  # For fully connected

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)  # Normalize
        x = self.relu(x)  # Then activate
        x = x.view(-1, 64 * 32 * 32)
        x = self.fc(x)
        return x

# Training vs. inference mode matters!
model.train()  # Uses batch statistics
model.eval()   # Uses running averages

import xgboost as xgb
from sklearn.model_selection import cross_val_score

# Basic XGBoost
model = xgb.XGBClassifier(
    n_estimators=100,
    max_depth=6,
    learning_rate=0.1,
    subsample=0.8,
    colsample_bytree=0.8,
    reg_alpha=0.1,  # L1 regularization
    reg_lambda=1.0,  # L2 regularization
    use_label_encoder=False,
    eval_metric='logloss'
)

model.fit(X_train, y_train)

# Feature importance
importance = model.feature_importances_

# Cross-validation
scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')

import torch
import torch.nn as nn
import math

class SelfAttention(nn.Module):
    def __init__(self, embed_dim, num_heads):
        super().__init__()
        self.embed_dim = embed_dim
        self.num_heads = num_heads
        self.head_dim = embed_dim // num_heads

        self.q_linear = nn.Linear(embed_dim, embed_dim)
        self.k_linear = nn.Linear(embed_dim, embed_dim)
        self.v_linear = nn.Linear(embed_dim, embed_dim)
        self.out = nn.Linear(embed_dim, embed_dim)

    def forward(self, x, mask=None):
        batch_size = x.size(0)

        # Linear projections
        Q = self.q_linear(x)
        K = self.k_linear(x)
        V = self.v_linear(x)

        # Reshape for multi-head
        Q = Q.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
        K = K.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
        V = V.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)

        # Scaled dot-product attention
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.head_dim)

        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)

        attention = torch.softmax(scores, dim=-1)
        out = torch.matmul(attention, V)

        # Concatenate heads
        out = out.transpose(1, 2).contiguous().view(batch_size, -1, self.embed_dim)
        return self.out(out)

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler, OneHotEncoder

# 1. Date/Time features
df['day_of_week'] = df['date'].dt.dayofweek
df['hour'] = df['date'].dt.hour
df['is_weekend'] = df['day_of_week'].isin([5, 6]).astype(int)
df['month_sin'] = np.sin(2 * np.pi * df['date'].dt.month / 12)  # Cyclical

# 2. Aggregation features
df['user_total_purchases'] = df.groupby('user_id')['amount'].transform('sum')
df['user_avg_purchase'] = df.groupby('user_id')['amount'].transform('mean')
df['user_purchase_count'] = df.groupby('user_id')['amount'].transform('count')

# 3. Text features
df['text_length'] = df['text'].str.len()
df['word_count'] = df['text'].str.split().str.len()
df['has_question'] = df['text'].str.contains(r'\?').astype(int)

# 4. Interaction features
df['price_per_sqft'] = df['price'] / df['sqft']
df['bmi'] = df['weight'] / (df['height'] ** 2)

# 5. Binning
df['age_group'] = pd.cut(df['age'], bins=[0, 18, 35, 50, 100], 
                         labels=['child', 'young', 'middle', 'senior'])

# 6. Target encoding (for categorical)
target_means = df.groupby('category')['target'].mean()
df['category_encoded'] = df['category'].map(target_means)

# 7. Log transformation (for skewed data)
df['log_income'] = np.log1p(df['income'])  # log1p handles zeros

import shap

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

# Create explainer
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)

# Summary plot (global importance)
shap.summary_plot(shap_values, X_test)

# Force plot (single prediction)
shap.force_plot(explainer.expected_value, 
               shap_values[0], X_test.iloc[0])

# Dependence plot (feature interaction)
shap.dependence_plot("age", shap_values, X_test)

from lime import lime_tabular

explainer = lime_tabular.LimeTabularExplainer(
    X_train.values,
    feature_names=X_train.columns,
    class_names=['No', 'Yes'],
    mode='classification'
)

# Explain single prediction
exp = explainer.explain_instance(
    X_test.iloc[0].values,
    model.predict_proba,
    num_features=10
)
exp.show_in_notebook()

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.ensemble import RandomForestClassifier

# Grid Search
param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [5, 10, 15, None],
    'min_samples_split': [2, 5, 10]
}

grid_search = GridSearchCV(
    RandomForestClassifier(),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1
)
grid_search.fit(X_train, y_train)
print(f"Best params: {grid_search.best_params_}")

# Random Search (often better)
from scipy.stats import randint, uniform

param_dist = {
    'n_estimators': randint(100, 500),
    'max_depth': randint(3, 20),
    'min_samples_split': randint(2, 20)
}

random_search = RandomizedSearchCV(
    RandomForestClassifier(),
    param_dist,
    n_iter=50,  # Number of random combinations
    cv=5,
    random_state=42
)
random_search.fit(X_train, y_train)

import optuna

def objective(trial):
    params = {
        'n_estimators': trial.suggest_int('n_estimators', 100, 500),
        'max_depth': trial.suggest_int('max_depth', 3, 20),
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3, log=True)
    }

    model = xgb.XGBClassifier(**params)
    score = cross_val_score(model, X, y, cv=5).mean()
    return score

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100)

print(f"Best params: {study.best_params}")

# ❌ WRONG: Preprocessing before split
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # Sees all data!
X_train, X_test = train_test_split(X_scaled, ...)

# ✅ CORRECT: Preprocess after split
X_train, X_test, y_train, y_test = train_test_split(X, y, ...)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)  # Fit on train only
X_test_scaled = scaler.transform(X_test)  # Transform with train params

# ✅ BEST: Use Pipeline
from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', RandomForestClassifier())
])

# Cross-validation respects the pipeline
scores = cross_val_score(pipeline, X, y, cv=5)

# ❌ WRONG: Random split for time series
X_train, X_test = train_test_split(df, test_size=0.2, random_state=42)

# ✅ CORRECT: Temporal split
train = df[df['date'] < '2024-01-01']
test = df[df['date'] >= '2024-01-01']

# Or use TimeSeriesSplit
from sklearn.model_selection import TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=5)

from scipy import stats

def calculate_sample_size(baseline_rate, mde, alpha=0.05, power=0.8):
    """
    baseline_rate: Current conversion rate
    mde: Minimum detectable effect (relative change)
    """
    effect_size = baseline_rate * mde
    z_alpha = stats.norm.ppf(1 - alpha/2)
    z_power = stats.norm.ppf(power)

    p = baseline_rate
    p_hat = (p + (p + effect_size)) / 2

    n = (z_alpha * (2 * p_hat * (1 - p_hat))**0.5 + 
         z_power * (p * (1-p) + (p + effect_size) * (1 - (p + effect_size)))**0.5)**2 / effect_size**2

    return int(n)

# Example: 5% baseline, detect 10% relative improvement
n = calculate_sample_size(0.05, 0.10)
print(f"Need {n} samples per group")

from scipy import stats

def ab_test_significance(control_conversions, control_total,
                        treatment_conversions, treatment_total):
    control_rate = control_conversions / control_total
    treatment_rate = treatment_conversions / treatment_total

    # Two-proportion z-test
    pooled = (control_conversions + treatment_conversions) / (control_total + treatment_total)
    se = (pooled * (1 - pooled) * (1/control_total + 1/treatment_total)) ** 0.5
    z = (treatment_rate - control_rate) / se
    p_value = 2 * (1 - stats.norm.cdf(abs(z)))

    return {
        'control_rate': control_rate,
        'treatment_rate': treatment_rate,
        'lift': (treatment_rate - control_rate) / control_rate,
        'p_value': p_value,
        'significant': p_value < 0.05
    }

# User-based: Find similar users
from sklearn.metrics.pairwise import cosine_similarity

user_similarity = cosine_similarity(user_item_matrix)

# Item-based: Find similar items
item_similarity = cosine_similarity(user_item_matrix.T)

# Matrix Factorization (SVD)
from scipy.sparse.linalg import svds

U, sigma, Vt = svds(user_item_matrix, k=50)
predicted_ratings = np.dot(np.dot(U, np.diag(sigma)), Vt)

import torch.nn as nn

class NeuralCollaborativeFiltering(nn.Module):
    def __init__(self, num_users, num_items, embed_dim=32):
        super().__init__()
        self.user_embed = nn.Embedding(num_users, embed_dim)
        self.item_embed = nn.Embedding(num_items, embed_dim)

        self.mlp = nn.Sequential(
            nn.Linear(embed_dim * 2, 64),
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 1)
        )

    def forward(self, user_ids, item_ids):
        user_emb = self.user_embed(user_ids)
        item_emb = self.item_embed(item_ids)
        x = torch.cat([user_emb, item_emb], dim=-1)
        return self.mlp(x).squeeze()

from sklearn.feature_extraction.text import TfidfVectorizer

# Create item profiles from descriptions
tfidf = TfidfVectorizer(stop_words='english')
item_features = tfidf.fit_transform(item_descriptions)

# Create user profile from liked items
user_profile = item_features[liked_items].mean(axis=0)

# Recommend similar items
similarities = cosine_similarity(user_profile, item_features)

from imblearn.over_sampling import SMOTE
from imblearn.under_sampling import RandomUnderSampler
from imblearn.pipeline import Pipeline as ImbPipeline

# SMOTE oversampling
smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)

# Combination: SMOTE + undersampling
pipeline = ImbPipeline([
    ('over', SMOTE(sampling_strategy=0.3)),
    ('under', RandomUnderSampler(sampling_strategy=0.5)),
    ('model', RandomForestClassifier())
])

# Class weights (no resampling needed)
from sklearn.utils.class_weight import compute_class_weight

weights = compute_class_weight('balanced', classes=np.unique(y), y=y)
model = RandomForestClassifier(class_weight='balanced')

# Or in XGBoost
scale_pos_weight = len(y_train[y_train==0]) / len(y_train[y_train==1])
model = xgb.XGBClassifier(scale_pos_weight=scale_pos_weight)

from sklearn.metrics import precision_recall_curve

# Get probabilities
y_proba = model.predict_proba(X_test)[:, 1]

# Find optimal threshold for F1
precision, recall, thresholds = precision_recall_curve(y_test, y_proba)
f1_scores = 2 * (precision * recall) / (precision + recall + 1e-10)
optimal_threshold = thresholds[np.argmax(f1_scores)]

# Use custom threshold
y_pred = (y_proba >= optimal_threshold).astype(int)

from fastapi import FastAPI
import joblib
import numpy as np

app = FastAPI()
model = joblib.load('model.joblib')
scaler = joblib.load('scaler.joblib')

@app.post("/predict")
async def predict(features: list[float]):
    X = np.array(features).reshape(1, -1)
    X_scaled = scaler.transform(X)
    prediction = model.predict(X_scaled)
    probability = model.predict_proba(X_scaled)

    return {
        "prediction": int(prediction[0]),
        "probability": float(probability[0].max())
    }

FROM python:3.10-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt

COPY model.joblib .
COPY app.py .

CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

# Track prediction drift
from evidently import Report
from evidently.metrics import DataDriftPreset

report = Report(metrics=[DataDriftPreset()])
report.run(reference_data=train_df, current_data=production_df)
report.save_html("drift_report.html")

import mlflow

with mlflow.start_run():
    mlflow.log_params(params)
    mlflow.log_metrics(metrics)
    mlflow.sklearn.log_model(model, "model")

from sklearn.linear_model import LinearRegression
import numpy as np

# Simple linear regression
model = LinearRegression()
model.fit(X_train, y_train)

print(f"Coefficients: {model.coef_}")
print(f"Intercept: {model.intercept_}")
print(f"R² Score: {model.score(X_test, y_test)}")

from statsmodels.stats.outliers_influence import variance_inflation_factor

# Check multicollinearity
vif = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]
print("VIF:", dict(zip(X.columns, vif)))  # VIF > 5 = problem

# Residual analysis
residuals = y_test - model.predict(X_test)

from sklearn.linear_model import LogisticRegression

model = LogisticRegression(penalty='l2', C=1.0, solver='lbfgs')
model.fit(X_train, y_train)

# Probabilities
probabilities = model.predict_proba(X_test)

# Coefficients (log-odds)
print("Coefficients:", model.coef_)

# Odds ratio interpretation
import numpy as np
odds_ratios = np.exp(model.coef_)
print("Odds Ratios:", odds_ratios)

from sklearn.naive_bayes import GaussianNB, MultinomialNB, BernoulliNB

# For continuous features
gnb = GaussianNB()

# For text/count data (most common)
mnb = MultinomialNB(alpha=1.0)  # alpha = Laplace smoothing

# For binary features
bnb = BernoulliNB()

# Text classification example
from sklearn.feature_extraction.text import CountVectorizer

vectorizer = CountVectorizer()
X_train_counts = vectorizer.fit_transform(train_texts)

mnb.fit(X_train_counts, y_train)
predictions = mnb.predict(vectorizer.transform(test_texts))

from sklearn.feature_selection import SelectKBest, f_classif, mutual_info_classif

# ANOVA F-test (for classification)
selector = SelectKBest(f_classif, k=10)
X_selected = selector.fit_transform(X, y)

# Correlation-based
correlation_matrix = X.corr()
high_corr_features = correlation_matrix[abs(correlation_matrix) > 0.8]

# Variance threshold
from sklearn.feature_selection import VarianceThreshold
selector = VarianceThreshold(threshold=0.01)

from sklearn.feature_selection import RFE, RFECV
from sklearn.ensemble import RandomForestClassifier

# Recursive Feature Elimination
rfe = RFE(estimator=RandomForestClassifier(), n_features_to_select=10)
rfe.fit(X, y)
selected_features = X.columns[rfe.support_]

# With cross-validation
rfecv = RFECV(estimator=RandomForestClassifier(), cv=5)
rfecv.fit(X, y)

# L1 regularization (Lasso)
from sklearn.linear_model import LassoCV
lasso = LassoCV(cv=5).fit(X, y)
selected = X.columns[lasso.coef_ != 0]

# Tree-based feature importance
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier().fit(X, y)
importances = pd.Series(rf.feature_importances_, index=X.columns)
top_features = importances.nlargest(10).index

from sklearn.ensemble import BaggingClassifier, RandomForestClassifier

# Random Forest is bagging + feature randomization
rf = RandomForestClassifier(n_estimators=100, max_features='sqrt')

# Generic bagging
bagging = BaggingClassifier(
    estimator=DecisionTreeClassifier(),
    n_estimators=50,
    max_samples=0.8,
    bootstrap=True
)