forked from ccf-ai-infra/GPUCodeForces
98 lines
4.6 KiB
Plaintext
98 lines
4.6 KiB
Plaintext
You write custom CUDA kernels to replace the PyTorch operators in the given EvoNorm architecture to get speedups.
|
|
You have complete freedom to choose the set of operators you want to replace. You may make the decision to replace some operators with custom CUDA kernels and leave others unchanged. You may replace multiple operators with custom implementations, consider operator fusion opportunities (combining multiple operators into a single kernel, for example, combining normalization+affine_transform+nonlinear_gating), or algorithmic changes (such as optimized memory access patterns). You are only limited by your imagination.
|
|
|
|
Technical Overview: CUDA-Optimized Smooth L1 Loss (Huber Loss)
|
|
This implementation provides a high-performance CUDA kernel for computing Smooth L1 Loss, a robust loss function that combines the benefits of L1 and L2 losses, designed for regression tasks with optimized parallel computation.
|
|
Key Features:
|
|
Architecture:
|
|
Custom CUDA kernel with inline compilation using PyTorch C++ extensions
|
|
Optimized for NVIDIA GPUs with warp-level and block-level parallel reduction
|
|
Supports 4-element vectorization (float4) for memory coalescing
|
|
Implements three reduction modes: 'none', 'mean', and 'sum'
|
|
Performance Optimizations:
|
|
Vectorized Memory Access: Uses float4 data type to process 4 elements simultaneously
|
|
Two-Phase Processing: Main loop processes vectorized elements, tail handles remaining elements
|
|
Parallel Reduction: Efficient warp and block-level reduction for sum/mean operations
|
|
Atomic Operations: Global atomic addition for final reduction across blocks
|
|
Coalesced Memory: Contiguous memory access patterns throughout
|
|
Kernel Specifications:
|
|
Block size: 256 threads
|
|
Warp size: 32 threads
|
|
Grid size: Adaptive based on input size (up to 1024 blocks)
|
|
Memory alignment: Requires element count divisible by 4 for optimal vectorization
|
|
Reduction Modes:
|
|
'none': Returns element-wise loss tensor of same shape as input
|
|
'mean': Returns scalar mean loss across all elements
|
|
'sum': Returns scalar sum loss across all elements
|
|
Key Components:
|
|
Conditional Loss Calculation: Branch-based selection between L2 (quadratic) and L1 (linear) regimes
|
|
Beta Parameter: Threshold parameter controlling the transition between L1 and L2 behavior
|
|
Numerical Stability: No explicit epsilon needed due to stable mathematical formulation
|
|
Efficient Reduction: Hierarchical reduction (warp → block → global) for parallel aggregation
|
|
Advantages over Standard Losses:
|
|
L1 Loss: Less sensitive to outliers but has discontinuous gradients
|
|
L2 Loss: Smooth gradients but overly sensitive to outliers
|
|
Smooth L1: Combines benefits - L2-like behavior near zero (smooth gradients) and L1-like behavior for large errors (robust to outliers)
|
|
Interface:
|
|
Input: Two tensors (input, target) of any identical shape
|
|
Parameters: Beta value (default=1.0) and reduction mode
|
|
Output: Scalar loss or element-wise loss tensor based on reduction mode
|
|
Automatic GPU tensor handling with device transfer and memory contiguity enforcement
|
|
Typical Applications:
|
|
Object detection (e.g., Faster R-CNN bounding box regression)
|
|
Robust regression tasks with potential outliers
|
|
Computer vision tasks requiring precise localization
|
|
Any regression problem where error distribution may contain outliers
|
|
|
|
|
|
Here's an example to show you the syntax of inline embedding custom CUDA operators in torch: The example given architecture is:
|
|
import torch
|
|
import torch.nn as nn
|
|
import torch.nn.functional as F
|
|
|
|
N, C, H, W = 32, 64, 56, 56
|
|
|
|
|
|
class SmoothL1Loss(nn.Module):
|
|
def __init__(self, reduction='mean', beta=1.0):
|
|
super().__init__()
|
|
self.reduction = reduction
|
|
self.beta = beta
|
|
|
|
def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
|
|
diff = torch.abs(input - target)
|
|
|
|
if self.beta == 0:
|
|
loss = diff
|
|
else:
|
|
loss = torch.where(
|
|
diff < self.beta,
|
|
0.5 * diff * diff / self.beta,
|
|
diff - 0.5 * self.beta
|
|
)
|
|
|
|
if self.reduction == 'mean':
|
|
return loss.mean()
|
|
elif self.reduction == 'sum':
|
|
return loss.sum()
|
|
else:
|
|
return loss
|
|
|
|
|
|
class Model(nn.Module):
|
|
def __init__(self, reduction='mean', beta=1.0):
|
|
super().__init__()
|
|
self.op = SmoothL1Loss(reduction, beta)
|
|
|
|
def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
|
|
return self.op(input, target)
|
|
|
|
|
|
def get_inputs():
|
|
input = torch.randn(N, C, H, W, dtype=torch.float32)
|
|
target = torch.randn(N, C, H, W, dtype=torch.float32)
|
|
return [input, target]
|
|
|
|
|
|
def get_init_inputs():
|
|
return ['mean', 1.0] |