Computer Vision

import torch.nn as nn

# PyTorch Conv2d
conv_layer = nn.Conv2d(
    in_channels=3,      # (#1:RGB input)
    out_channels=64,    # (#2:Number of filters)
    kernel_size=3,      # (#3:3x3 kernel)
    stride=1,           # (#4:Step size)
    padding=1           # (#5:Same padding)
)

# TensorFlow/Keras equivalent
from tensorflow.keras.layers import Conv2D

conv_layer = Conv2D(
    filters=64,
    kernel_size=(3, 3),
    strides=(1, 1),
    padding='same',     # (#6:Output same size as input)
    activation='relu'   # (#7:Activation included)
)

import torch
import torch.nn as nn

# Input: batch of 4 images, 64 channels, 32x32 spatial
x = torch.randn(4, 64, 32, 32)  # (#1:NCHW format)

# Max Pooling - reduces spatial by 2x
max_pool = nn.MaxPool2d(kernel_size=2, stride=2)
out = max_pool(x)  # (#2:Shape: (4, 64, 16, 16))

# Global Average Pooling - reduces to 1x1
gap = nn.AdaptiveAvgPool2d((1, 1))
out = gap(x)  # (#3:Shape: (4, 64, 1, 1))

# Flatten for fully connected layer
out = out.view(out.size(0), -1)  # (#4:Shape: (4, 64))

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-5, 5, 100)

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

# ReLU: f(x) = max(0, x)
axes[0,0].plot(x, np.maximum(0, x), 'b-', linewidth=2)
axes[0,0].axhline(y=0, color='k', linestyle='--', alpha=0.3)
axes[0,0].axvline(x=0, color='k', linestyle='--', alpha=0.3)
axes[0,0].set_title('ReLU: max(0, x)')
axes[0,0].set_ylim(-1, 5)

# Sigmoid: f(x) = 1/(1+e^-x)
axes[0,1].plot(x, 1/(1+np.exp(-x)), 'r-', linewidth=2)
axes[0,1].axhline(y=0.5, color='k', linestyle='--', alpha=0.3)
axes[0,1].set_title('Sigmoid: 1/(1+e^-x)')
axes[0,1].set_ylim(-0.1, 1.1)

# LeakyReLU: f(x) = max(0.1x, x)
axes[1,0].plot(x, np.where(x > 0, x, 0.1*x), 'g-', linewidth=2)
axes[1,0].axhline(y=0, color='k', linestyle='--', alpha=0.3)
axes[1,0].set_title('LeakyReLU: max(0.1x, x)')

# Softmax example (3 classes)
logits = np.array([2.0, 1.0, 0.1])
softmax = np.exp(logits) / np.sum(np.exp(logits))
axes[1,1].bar(['Class A', 'Class B', 'Class C'], softmax, color=['blue', 'orange', 'green'])
axes[1,1].set_title(f'Softmax: probabilities sum to {softmax.sum():.1f}')

plt.tight_layout()
plt.savefig('activation_plots.png')

import torch
import torch.nn as nn
import torch.nn.functional as F

x = torch.randn(4, 64)  # (#1:Batch of 4, 64 features)

# ReLU - Most common for hidden layers
relu = nn.ReLU()
out = relu(x)  # (#2:Zeros out negatives)

# LeakyReLU - Allows small negative gradient
leaky = nn.LeakyReLU(negative_slope=0.01)
out = leaky(x)  # (#3:Prevents dying ReLU)

# Sigmoid - Binary classification output
out = torch.sigmoid(x)  # (#4:Range [0, 1])

# Softmax - Multi-class classification
out = F.softmax(x, dim=1)  # (#5:Probabilities sum to 1)

# GELU - Used in Transformers
gelu = nn.GELU()
out = gelu(x)  # (#6:Smooth ReLU variant)

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

# Load pretrained VGG-16
vgg16 = models.vgg16(weights='IMAGENET1K_V1')  # (#1:Pretrained weights)

# Custom VGG-like block
class VGGBlock(nn.Module):
    def __init__(self, in_ch, out_ch, num_convs):
        super().__init__()
        layers = []
        for i in range(num_convs):
            layers.append(nn.Conv2d(
                in_ch if i == 0 else out_ch,  # (#2:First conv changes channels)
                out_ch, kernel_size=3, padding=1
            ))
            layers.append(nn.ReLU(inplace=True))
        layers.append(nn.MaxPool2d(2, 2))  # (#3:Halve spatial dims)
        self.block = nn.Sequential(*layers)

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

import torch.nn as nn

class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels,
                               kernel_size=3, stride=stride, padding=1)  # (#1:May downsample)
        self.bn1 = nn.BatchNorm2d(out_channels)  # (#2:Batch normalization)
        self.conv2 = nn.Conv2d(out_channels, out_channels,
                               kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

        # Skip connection with projection if dimensions change
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, 1, stride),  # (#3:1x1 conv to match dims)
                nn.BatchNorm2d(out_channels)
            )

    def forward(self, x):
        identity = self.shortcut(x)  # (#4:Skip connection)
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += identity  # (#5:Add residual)
        return self.relu(out)

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

# Load pretrained EfficientNet
efficientnet = models.efficientnet_b0(weights='IMAGENET1K_V1')  # (#1:5.3M params)

# Modify for custom number of classes
num_classes = 10
efficientnet.classifier = nn.Sequential(
    nn.Dropout(p=0.2, inplace=True),
    nn.Linear(1280, num_classes)  # (#2:Replace final layer)
)

# EfficientNet-V2 (improved version)
efficientnet_v2 = models.efficientnet_v2_s(weights='IMAGENET1K_V1')  # (#3:Faster training)

# Timm library - more options
import timm
model = timm.create_model('efficientnet_b3', pretrained=True, num_classes=10)  # (#4:Easy model creation)

import torch
import torch.nn as nn
from transformers import ViTForImageClassification, ViTImageProcessor

# Using Hugging Face Transformers
model_name = "google/vit-base-patch16-224"  # (#1:16x16 patches, 224x224 input)
processor = ViTImageProcessor.from_pretrained(model_name)  # (#2:Preprocessing)
model = ViTForImageClassification.from_pretrained(model_name)

# Using timm library
import timm
vit = timm.create_model('vit_base_patch16_224', pretrained=True, num_classes=10)  # (#3:Easy setup)

# PyTorch native (torchvision)
from torchvision.models import vit_b_16, ViT_B_16_Weights
vit = vit_b_16(weights=ViT_B_16_Weights.IMAGENET1K_V1)  # (#4:Pretrained)
vit.heads = nn.Linear(768, 10)  # (#5:Custom head)

import timm
import torchvision.models as models

# ConvNeXt - CNN competitive with ViT
convnext = models.convnext_tiny(weights='IMAGENET1K_V1')  # (#1:28.6M params)
convnext_base = timm.create_model('convnext_base', pretrained=True)  # (#2:Via timm)

# Swin Transformer
swin = models.swin_t(weights='IMAGENET1K_V1')  # (#3:Swin-Tiny)
swin_base = timm.create_model('swin_base_patch4_window7_224', pretrained=True)  # (#4:Base model)

# Modify for custom classes
num_classes = 10
convnext.classifier[2] = nn.Linear(768, num_classes)  # (#5:ConvNeXt head)
swin.head = nn.Linear(768, num_classes)  # (#6:Swin head)

from ultralytics import YOLO

# Load pretrained model
model = YOLO('yolov8n.pt')  # (#1:Nano model - fastest)
# Options: yolov8n, yolov8s, yolov8m, yolov8l, yolov8x

# Run inference
results = model('image.jpg')  # (#2:Single image)
results = model(['img1.jpg', 'img2.jpg'])  # (#3:Batch inference)

# Process results
for result in results:
    boxes = result.boxes  # (#4:Bounding boxes)
    for box in boxes:
        xyxy = box.xyxy[0]  # (#5:x1, y1, x2, y2)
        conf = box.conf[0]  # (#6:Confidence score)
        cls = box.cls[0]    # (#7:Class index)

# Train custom model
model.train(data='custom.yaml', epochs=100, imgsz=640)  # (#8:Fine-tuning)

import segmentation_models_pytorch as smp

# Using segmentation_models_pytorch
model = smp.Unet(
    encoder_name="resnet34",        # (#1:Pretrained backbone)
    encoder_weights="imagenet",      # (#2:ImageNet weights)
    in_channels=3,                   # (#3:RGB input)
    classes=1,                       # (#4:Binary segmentation)
)

# U-Net++ (improved skip connections)
model = smp.UnetPlusPlus(
    encoder_name="efficientnet-b3",
    encoder_weights="imagenet",
    classes=5,  # (#5:Multi-class segmentation)
)

# Using Hugging Face
from transformers import SegformerForSemanticSegmentation
model = SegformerForSemanticSegmentation.from_pretrained(
    "nvidia/segformer-b0-finetuned-ade-512-512"  # (#6:Pretrained segmentation)
)

from segment_anything import sam_model_registry, SamPredictor

# Load SAM model
sam = sam_model_registry["vit_h"](checkpoint="sam_vit_h.pth")  # (#1:ViT-Huge)
predictor = SamPredictor(sam)

# Set image (encodes once)
image = cv2.imread("image.jpg")
predictor.set_image(image)  # (#2:Run image encoder)

# Predict with point prompt
input_point = np.array([[500, 375]])  # (#3:Click location)
input_label = np.array([1])  # (#4:1=foreground, 0=background)
masks, scores, logits = predictor.predict(
    point_coords=input_point,
    point_labels=input_label,
    multimask_output=True  # (#5:Returns 3 masks)
)

# Predict with box prompt
input_box = np.array([100, 100, 400, 400])  # (#6:x1, y1, x2, y2)
masks, _, _ = predictor.predict(box=input_box)

import torch
import torch.nn as nn

# Binary Cross-Entropy (with logits)
criterion = nn.BCEWithLogitsLoss()  # (#1:Includes sigmoid)
loss = criterion(predictions, targets)

# Multi-class Cross-Entropy
criterion = nn.CrossEntropyLoss()  # (#2:Includes softmax)
loss = criterion(predictions, targets)  # (#3:targets: class indices)

# Dice Loss for segmentation
def dice_loss(pred, target, smooth=1e-6):
    pred = torch.sigmoid(pred)  # (#4:Convert to probabilities)
    intersection = (pred * target).sum()
    union = pred.sum() + target.sum()
    dice = (2. * intersection + smooth) / (union + smooth)  # (#5:Dice coefficient)
    return 1 - dice  # (#6:Loss = 1 - coefficient)

# Combined loss (common for segmentation)
loss = 0.5 * bce_loss + 0.5 * dice_loss  # (#7:Balance both objectives)

import torch.optim as optim

# Basic optimizer setup
optimizer = optim.AdamW(
    model.parameters(),
    lr=1e-4,           # (#1:Learning rate)
    weight_decay=0.01  # (#2:L2 regularization)
)

# Different LR for different layers (transfer learning)
optimizer = optim.AdamW([
    {'params': model.backbone.parameters(), 'lr': 1e-5},  # (#3:Pretrained - low LR)
    {'params': model.head.parameters(), 'lr': 1e-3}       # (#4:New layers - high LR)
])

# Training step
optimizer.zero_grad()  # (#5:Clear gradients)
loss = criterion(model(inputs), targets)
loss.backward()        # (#6:Compute gradients)
optimizer.step()       # (#7:Update weights)

from torch.optim.lr_scheduler import CosineAnnealingLR, OneCycleLR

# Cosine Annealing
scheduler = CosineAnnealingLR(
    optimizer,
    T_max=100,        # (#1:Total epochs)
    eta_min=1e-6      # (#2:Minimum LR)
)

# OneCycleLR (recommended for fast training)
scheduler = OneCycleLR(
    optimizer,
    max_lr=1e-3,      # (#3:Peak learning rate)
    epochs=100,
    steps_per_epoch=len(train_loader),  # (#4:Total steps)
    pct_start=0.1     # (#5:10% warmup)
)

# Training loop
for epoch in range(epochs):
    for batch in train_loader:
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        scheduler.step()  # (#6:Update LR each step for OneCycleLR)
    # scheduler.step()  # (#7:Or once per epoch for others)