Computer Vision

from tensorflow.keras.applications import (
    ResNet50, VGG16, EfficientNetB0, MobileNetV2
)

# Load model with ImageNet weights
base_model = ResNet50(
    weights='imagenet',  # (#1:Pretrained on ImageNet)
    include_top=False,   # (#2:Remove classification head)
    input_shape=(224, 224, 3)
)

# Check model architecture
base_model.summary()

# Available models: VGG16, VGG19, ResNet50/101/152,
# InceptionV3, EfficientNetB0-B7, MobileNetV2/V3, etc.

import torchvision.models as models

# Load pretrained ResNet50
model = models.resnet50(pretrained=True)  # (#1:ImageNet weights)

# Modern syntax (PyTorch 2.0+)
from torchvision.models import ResNet50_Weights
model = models.resnet50(weights=ResNet50_Weights.IMAGENET1K_V2)  # (#2:Specific weights)

# Remove classification head
import torch.nn as nn
model.fc = nn.Identity()  # (#3:Replace final layer)

# Or get features directly
model = models.resnet50(pretrained=True)
features = nn.Sequential(*list(model.children())[:-1])  # (#4:All but last layer)

import timm

# List available models
print(timm.list_models('*efficientnet*'))  # (#1:Search models)

# Load model with pretrained weights
model = timm.create_model(
    'efficientnet_b0',
    pretrained=True,  # (#2:Download pretrained weights)
    num_classes=10    # (#3:Custom number of classes)
)

# Load as feature extractor
model = timm.create_model(
    'vit_base_patch16_224',
    pretrained=True,
    num_classes=0  # (#4:0 removes classifier)
)

# timm has 700+ models: ViT, Swin, ConvNeXt, etc.

import torch
import torch.nn as nn
from torchvision import models

class FeatureExtractor(nn.Module):
    def __init__(self, num_classes):
        super().__init__()
        # Load pretrained backbone
        self.backbone = models.resnet50(pretrained=True)

        # Freeze all layers
        for param in self.backbone.parameters():  # (#1:Freeze backbone)
            param.requires_grad = False

        # Replace classifier
        num_features = self.backbone.fc.in_features
        self.backbone.fc = nn.Sequential(
            nn.Linear(num_features, 256),  # (#2:New classifier head)
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(256, num_classes)
        )

    def forward(self, x):
        return self.backbone(x)

# Keras: Freeze early layers, unfreeze later ones
base_model = ResNet50(weights='imagenet', include_top=False)

# Freeze first N layers
for layer in base_model.layers[:100]:  # (#1:Freeze early layers)
    layer.trainable = False
for layer in base_model.layers[100:]:  # (#2:Unfreeze later layers)
    layer.trainable = True

# PyTorch: Freeze by layer name
model = models.resnet50(pretrained=True)
for name, param in model.named_parameters():
    if 'layer4' in name or 'fc' in name:  # (#3:Unfreeze layer4 and fc)
        param.requires_grad = True
    else:
        param.requires_grad = False  # (#4:Freeze other layers)

# Check trainable parameters
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"Trainable params: {trainable:,}")

# Different learning rates for different layers
model = models.resnet50(pretrained=True)

# Group parameters by layer depth
param_groups = [
    {'params': model.conv1.parameters(), 'lr': 1e-6},   # (#1:Lowest LR for early layers)
    {'params': model.layer1.parameters(), 'lr': 1e-6},
    {'params': model.layer2.parameters(), 'lr': 1e-5},
    {'params': model.layer3.parameters(), 'lr': 1e-5},
    {'params': model.layer4.parameters(), 'lr': 1e-4},  # (#2:Higher LR for later layers)
    {'params': model.fc.parameters(), 'lr': 1e-3}       # (#3:Highest LR for new head)
]

optimizer = torch.optim.Adam(param_groups)

# Keras equivalent using layer-wise LR multiplier
# Requires custom training loop or optimizer modification

from sklearn.metrics import (
    confusion_matrix, classification_report, f1_score
)
import seaborn as sns
import matplotlib.pyplot as plt

# Predictions
y_pred = model.predict(X_test).argmax(axis=1)

# F1 Score
f1 = f1_score(y_true, y_pred, average='weighted')  # (#1:Weighted for imbalanced data)
print(f"F1 Score: {f1:.4f}")

# Confusion Matrix
cm = confusion_matrix(y_true, y_pred)  # (#2:Shows prediction distribution)

# Visualize
plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')  # (#3:Heatmap visualization)
plt.xlabel('Predicted')
plt.ylabel('True')
plt.title('Confusion Matrix')
plt.show()

from sklearn.metrics import roc_curve, auc, classification_report
import numpy as np

# Get probability predictions
y_proba = model.predict(X_test)  # (#1:Softmax probabilities)

# For binary classification
fpr, tpr, thresholds = roc_curve(y_true, y_proba[:, 1])  # (#2:False/True positive rates)
roc_auc = auc(fpr, tpr)

# Plot ROC curve
plt.plot(fpr, tpr, label=f'ROC (AUC = {roc_auc:.3f})')
plt.plot([0, 1], [0, 1], 'k--')  # (#3:Random baseline)
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.legend()
plt.show()

# Classification report (precision, recall, f1 per class)
print(classification_report(y_true, y_pred, target_names=class_names))  # (#4:Full report)

from sklearn.preprocessing import label_binarize
from sklearn.metrics import roc_auc_score

# One-vs-Rest AUC
y_true_bin = label_binarize(y_true, classes=range(num_classes))  # (#1:One-hot encode)

# Calculate AUC
auc_ovr = roc_auc_score(
    y_true_bin, y_proba,
    multi_class='ovr',  # (#2:One-vs-Rest strategy)
    average='weighted'
)
print(f"Weighted OvR AUC: {auc_ovr:.4f}")

# Plot ROC for each class
for i in range(num_classes):
    fpr, tpr, _ = roc_curve(y_true_bin[:, i], y_proba[:, i])
    plt.plot(fpr, tpr, label=f'Class {i} (AUC={auc(fpr, tpr):.2f})')  # (#3:Per-class curves)

plt.legend()
plt.show()

import numpy as np

def dice_coefficient(pred, target, smooth=1e-6):
    """Dice = 2 * |A intersection B| / (|A| + |B|)"""
    intersection = np.sum(pred * target)  # (#1:Pixel overlap)
    return (2 * intersection + smooth) / (np.sum(pred) + np.sum(target) + smooth)

def iou_score(pred, target, smooth=1e-6):
    """IoU = |A intersection B| / |A union B|"""
    intersection = np.sum(pred * target)
    union = np.sum(pred) + np.sum(target) - intersection  # (#2:Union calculation)
    return (intersection + smooth) / (union + smooth)

def pixel_accuracy(pred, target):
    """Simple accuracy per pixel"""
    return np.mean(pred == target)  # (#3:Correct pixels / Total)

# Per-class metrics
def mean_iou(pred, target, num_classes):
    ious = []
    for c in range(num_classes):
        iou = iou_score(pred == c, target == c)  # (#4:IoU per class)
        ious.append(iou)
    return np.mean(ious)

# Keras
from tensorflow.keras import layers

model = keras.Sequential([
    layers.Conv2D(64, 3, activation='relu'),
    layers.Dropout(0.25),  # (#1:25% dropout after conv)
    layers.Flatten(),
    layers.Dense(256, activation='relu'),
    layers.Dropout(0.5),  # (#2:50% dropout before output)
    layers.Dense(num_classes, activation='softmax')
])

# PyTorch
import torch.nn as nn

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, 3),
            nn.ReLU(),
            nn.Dropout2d(0.25)  # (#3:Spatial dropout for conv)
        )
        self.classifier = nn.Sequential(
            nn.Linear(64*26*26, 256),
            nn.ReLU(),
            nn.Dropout(0.5),  # (#4:Standard dropout for FC)
            nn.Linear(256, num_classes)
        )

# L2 Regularization (Weight Decay)
# Keras
from tensorflow.keras import regularizers

layers.Dense(256,
    kernel_regularizer=regularizers.l2(0.01)  # (#1:L2 penalty)
)

# PyTorch - weight decay in optimizer
optimizer = torch.optim.Adam(
    model.parameters(),
    lr=1e-3,
    weight_decay=1e-4  # (#2:L2 via optimizer)
)

# Batch Normalization - implicit regularization
# Keras
model.add(layers.BatchNormalization())  # (#3:After conv/dense)

# PyTorch
nn.Sequential(
    nn.Conv2d(64, 128, 3),
    nn.BatchNorm2d(128),  # (#4:Normalize activations)
    nn.ReLU()
)

from tensorflow.keras.callbacks import (
    ModelCheckpoint, EarlyStopping, ReduceLROnPlateau
)

# Save best model
checkpoint = ModelCheckpoint(
    'best_model.keras',
    monitor='val_loss',  # (#1:Track validation loss)
    save_best_only=True,
    mode='min'
)

# Stop when no improvement
early_stop = EarlyStopping(
    monitor='val_loss',
    patience=10,  # (#2:Wait 10 epochs)
    restore_best_weights=True  # (#3:Revert to best)
)

# Reduce LR on plateau
reduce_lr = ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.5,  # (#4:Halve learning rate)
    patience=5,
    min_lr=1e-7
)

callbacks = [checkpoint, early_stop, reduce_lr]
model.fit(X_train, y_train, callbacks=callbacks, epochs=100)

best_val_loss = float('inf')
patience_counter = 0
patience = 10

for epoch in range(num_epochs):
    # Training
    model.train()
    for batch in train_loader:
        # ... training step ...

    # Validation
    model.eval()
    val_loss = evaluate(model, val_loader)  # (#1:Calculate val loss)

    # Save best model
    if val_loss < best_val_loss:
        best_val_loss = val_loss
        torch.save(model.state_dict(), 'best_model.pt')  # (#2:Save checkpoint)
        patience_counter = 0
    else:
        patience_counter += 1

    # Early stopping
    if patience_counter >= patience:  # (#3:Stop if no improvement)
        print(f"Early stopping at epoch {epoch}")
        break

    # LR scheduling
    scheduler.step(val_loss)  # (#4:ReduceLROnPlateau)

import optuna

def objective(trial):
    # Suggest hyperparameters
    lr = trial.suggest_float('lr', 1e-5, 1e-2, log=True)  # (#1:Log-uniform)
    dropout = trial.suggest_float('dropout', 0.1, 0.5)
    batch_size = trial.suggest_categorical('batch_size', [16, 32, 64])  # (#2:Categorical)
    optimizer_name = trial.suggest_categorical('optimizer', ['Adam', 'SGD'])

    # Build model with suggested params
    model = build_model(dropout=dropout)

    # Train and evaluate
    accuracy = train_and_evaluate(
        model, lr=lr, batch_size=batch_size, optimizer=optimizer_name
    )

    return accuracy  # (#3:Maximize this)

# Create and run study
study = optuna.create_study(direction='maximize')  # (#4:Maximize accuracy)
study.optimize(objective, n_trials=100)

# Best parameters
print(f"Best params: {study.best_params}")
print(f"Best accuracy: {study.best_value:.4f}")

# Enable pruning for unpromising trials
def objective(trial):
    model = build_model(trial)

    for epoch in range(num_epochs):
        train(model)
        val_acc = evaluate(model)

        # Report intermediate value
        trial.report(val_acc, epoch)  # (#1:Report progress)

        # Check if trial should be pruned
        if trial.should_prune():  # (#2:Prune bad trials)
            raise optuna.TrialPruned()

    return val_acc

# Create study with pruner
study = optuna.create_study(
    direction='maximize',
    pruner=optuna.pruners.MedianPruner()  # (#3:Prune below median)
)

# Visualize results
from optuna.visualization import plot_optimization_history, plot_param_importances
plot_optimization_history(study)  # (#4:Show progress)
plot_param_importances(study)  # (#5:Parameter importance)

# Define sweep configuration
sweep_config = {
    'method': 'bayes',  # (#1:Bayesian optimization)
    'metric': {'name': 'val_accuracy', 'goal': 'maximize'},
    'parameters': {
        'learning_rate': {
            'distribution': 'log_uniform_values',  # (#2:Log-uniform sampling)
            'min': 1e-5, 'max': 1e-2
        },
        'dropout': {'values': [0.2, 0.3, 0.4, 0.5]},  # (#3:Discrete values)
        'batch_size': {'values': [16, 32, 64]},
        'optimizer': {'values': ['adam', 'sgd']}
    }
}

# Create sweep
sweep_id = wandb.sweep(sweep_config, project='cv-sweeps')

# Define training function
def train_sweep():
    wandb.init()
    config = wandb.config  # (#4:Get suggested params)
    model = build_model(config.dropout)
    # ... train with config.learning_rate, etc.

# Run sweep
wandb.agent(sweep_id, train_sweep, count=50)  # (#5:Run 50 trials)

# Use a standard dataset for practice
import tensorflow_datasets as tfds

# Load dataset
(train_ds, val_ds), info = tfds.load(
    'oxford_flowers102',  # (#1:102 flower classes)
    split=['train', 'validation'],
    with_info=True,
    as_supervised=True
)

# Preprocessing function
def preprocess(image, label):
    image = tf.image.resize(image, (224, 224))
    image = tf.keras.applications.efficientnet.preprocess_input(image)  # (#2:Model-specific preprocessing)
    return image, label

# Prepare datasets
BATCH_SIZE = 32
train_ds = train_ds.map(preprocess).batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)  # (#3:Optimize pipeline)
val_ds = val_ds.map(preprocess).batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)