From 6dbc3859e3efb639190f278408f0510917f3c7f5 Mon Sep 17 00:00:00 2001 From: Jorge Condor Date: Wed, 3 Jun 2026 09:18:52 +0200 Subject: [PATCH 1/2] fused CUDA kernel for puzzlesim --- .gitignore | 14 +- demo.ipynb | 539 ++++++++++++++++++-- puzzle_sim_cuda/README.md | 430 ++++++++++++++++ puzzle_sim_cuda/__init__.py | 30 ++ puzzle_sim_cuda/benchmark.py | 548 +++++++++++++++++++++ puzzle_sim_cuda/build.py | 54 ++ puzzle_sim_cuda/examples/loss_demo.py | 174 +++++++ puzzle_sim_cuda/puzzle_sim_cuda.py | 432 ++++++++++++++++ puzzle_sim_cuda/puzzle_sim_cuda_fused.py | 245 +++++++++ puzzle_sim_cuda/requirements.txt | 17 + puzzle_sim_cuda/setup.py | 62 +++ puzzle_sim_cuda/src/fused_inference.cpp | 529 ++++++++++++++++++++ puzzle_sim_cuda/src/kernels.cu | 404 +++++++++++++++ puzzle_sim_cuda/src/puzzle_sim_cuda.cpp | 321 ++++++++++++ puzzle_sim_cuda/tests/__init__.py | 0 puzzle_sim_cuda/tests/conftest.py | 98 ++++ puzzle_sim_cuda/tests/test_fused.py | 271 ++++++++++ puzzle_sim_cuda/tests/test_grad.py | 248 ++++++++++ puzzle_sim_cuda/tests/test_kernels.py | 152 ++++++ puzzle_sim_cuda/tests/test_puzzlesim.py | 138 ++++++ puzzle_sim_cuda/tests/test_real_data.py | 148 ++++++ puzzle_sim_cuda/tests/test_tensor_cores.py | 216 ++++++++ 22 files changed, 5017 insertions(+), 53 deletions(-) create mode 100644 puzzle_sim_cuda/README.md create mode 100644 puzzle_sim_cuda/__init__.py create mode 100644 puzzle_sim_cuda/benchmark.py create mode 100644 puzzle_sim_cuda/build.py create mode 100644 puzzle_sim_cuda/examples/loss_demo.py create mode 100644 puzzle_sim_cuda/puzzle_sim_cuda.py create mode 100644 puzzle_sim_cuda/puzzle_sim_cuda_fused.py create mode 100644 puzzle_sim_cuda/requirements.txt create mode 100644 puzzle_sim_cuda/setup.py create mode 100644 puzzle_sim_cuda/src/fused_inference.cpp create mode 100644 puzzle_sim_cuda/src/kernels.cu create mode 100644 puzzle_sim_cuda/src/puzzle_sim_cuda.cpp create mode 100644 puzzle_sim_cuda/tests/__init__.py create mode 100644 puzzle_sim_cuda/tests/conftest.py create mode 100644 puzzle_sim_cuda/tests/test_fused.py create mode 100644 puzzle_sim_cuda/tests/test_grad.py create mode 100644 puzzle_sim_cuda/tests/test_kernels.py create mode 100644 puzzle_sim_cuda/tests/test_puzzlesim.py create mode 100644 puzzle_sim_cuda/tests/test_real_data.py create mode 100644 puzzle_sim_cuda/tests/test_tensor_cores.py diff --git a/.gitignore b/.gitignore index 1059aa2..031e519 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,16 @@ .idea .vscode __pycache__ -.DS_Store \ No newline at end of file +.DS_Store + +# Compiled CUDA extension and build artifacts +puzzle_sim_cuda/build/ +puzzle_sim_cuda/dist/ +puzzle_sim_cuda/*.egg-info/ +puzzle_sim_cuda/*.pyd +puzzle_sim_cuda/*.so +puzzle_sim_cuda/*.log +.pytest_cache/ + +puzzle_sim\lpips_models\alex.pth +puzzle_sim\lpips_models\alex.pth \ No newline at end of file diff --git a/demo.ipynb b/demo.ipynb index 69e3c7f..0de6951 100644 --- a/demo.ipynb +++ b/demo.ipynb @@ -1,169 +1,604 @@ { "cells": [ { - "metadata": {}, "cell_type": "markdown", - "source": "# Puzzle Similarity Demo", - "id": "d0b5d694ce887ef6" + "id": "d0b5d694ce887ef6", + "metadata": {}, + "source": [ + "# Puzzle Similarity Demo - PyTorch vs CUDA Comparison\n", + "\n", + "This notebook demonstrates both the original PyTorch implementation and the optimized CUDA implementation of PuzzleSim, allowing for direct comparison of functionality and performance." + ] }, { "cell_type": "code", + "execution_count": 1, "id": "initial_id", "metadata": { - "collapsed": true, "ExecuteTime": { "end_time": "2024-11-29T16:27:50.990714Z", "start_time": "2024-11-29T16:27:47.348155Z" - } + }, + "collapsed": true }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: CUDA extension not available. Falling back to PyTorch implementation.\n", + "šŸ§© PuzzleSim CUDA System Information\n", + "==================================================\n", + "Package Version: 0.1.0\n", + "CUDA Extension: False\n", + "PyTorch Version: 2.6.0+cu126\n", + "CUDA Available: True\n", + "CUDA Devices: 1\n", + "Device Name: NVIDIA GeForce RTX 4090\n", + "Compute Capability: 8.9\n", + "\n", + "āš ļø CUDA extension not compiled!\n", + "Run 'make build' or 'python build.py' to compile CUDA kernels\n", + "āœ… CUDA implementation available\n", + "šŸ”„ Implementation comparison: Enabled\n", + "šŸ–„ļø CUDA device: NVIDIA GeForce RTX 4090\n" + ] + } + ], "source": [ "import torch\n", "import numpy as np\n", "import utils\n", - "from puzzle_sim import PuzzleSim" - ], - "outputs": [], - "execution_count": 1 + "import time\n", + "import sys\n", + "import os\n", + "from pathlib import Path\n", + "\n", + "# Environment setup\n", + "os.environ[\"KMP_DUPLICATE_LIB_OK\"] = \"TRUE\"\n", + "\n", + "# Import implementations\n", + "from puzzle_sim import PuzzleSim as PuzzleSimPyTorch\n", + "try:\n", + " from puzzle_sim_cuda import PuzzleSimCUDA\n", + " cuda_available = True\n", + " print(\"āœ… CUDA implementation available\")\n", + "except ImportError:\n", + " cuda_available = False\n", + " print(\"āŒ CUDA implementation not available - install puzzle_sim_cuda first\")\n", + "\n", + "# Configuration\n", + "COMPARE_IMPLEMENTATIONS = cuda_available and torch.cuda.is_available()\n", + "print(f\"šŸ”„ Implementation comparison: {'Enabled' if COMPARE_IMPLEMENTATIONS else 'Disabled'}\")\n", + "print(f\"šŸ–„ļø CUDA device: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'Not available'}\")" + ] }, { + "cell_type": "code", + "execution_count": 2, + "id": "c046784eac5cec31", "metadata": { "ExecuteTime": { "end_time": "2024-11-29T16:27:52.384834Z", "start_time": "2024-11-29T16:27:51.744398Z" } }, - "cell_type": "code", - "source": [ - "# select one of the datasets: \"flowers\", \"garden\", \"playroom\"\n", - "dataset = \"flowers\"\n", - "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n", - "priors, test_images, test_image_names = utils.load_images(dataset, device)\n", - "puzzle = PuzzleSim(priors, resize=(416, 628))\n", - "print(\"Loaded\", len(test_images), \"test images and\", len(priors), \"priors.\")" - ], - "id": "c046784eac5cec31", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Loaded 2 test images and 34 priors.\n" + "šŸ“ Loading dataset: flowers\n", + "Loaded 2 test images and 34 priors.\n", + "šŸ”§ Initializing PyTorch implementation...\n", + " Initialization time: 0.019s\n", + "šŸš€ Initializing CUDA implementation...\n", + " āŒ CUDA extension not compiled: CUDA extension not available. Please compile the CUDA extension first.\n", + " šŸ”§ To enable CUDA acceleration:\n", + " - Run: cd puzzle_sim_cuda\n", + " - Then: make build\n", + " - Or: python build.py\n", + "\n", + "šŸ“Š Available implementations: ['PyTorch']\n" ] } ], - "execution_count": 2 + "source": [ + "# Configuration\n", + "dataset = \"flowers\" # select one of: \"flowers\", \"garden\", \"playroom\"\n", + "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n", + "resize_dims = (416, 628)\n", + "\n", + "# Load data\n", + "print(f\"šŸ“ Loading dataset: {dataset}\")\n", + "priors, test_images, test_image_names = utils.load_images(dataset, device)\n", + "print(f\"Loaded {len(test_images)} test images and {len(priors)} priors.\")\n", + "\n", + "# Initialize implementations\n", + "implementations = {}\n", + "\n", + "# PyTorch implementation\n", + "print(\"šŸ”§ Initializing PyTorch implementation...\")\n", + "start_time = time.time()\n", + "puzzle_pytorch = PuzzleSimPyTorch(priors, resize=resize_dims)\n", + "pytorch_init_time = time.time() - start_time\n", + "implementations['PyTorch'] = {\n", + " 'model': puzzle_pytorch,\n", + " 'init_time': pytorch_init_time,\n", + " 'device': 'CPU/GPU'\n", + "}\n", + "print(f\" Initialization time: {pytorch_init_time:.3f}s\")\n", + "\n", + "# CUDA implementation (if available)\n", + "if COMPARE_IMPLEMENTATIONS:\n", + " print(\"šŸš€ Initializing CUDA implementation...\")\n", + " try:\n", + " start_time = time.time()\n", + " puzzle_cuda = PuzzleSimCUDA(priors, resize=resize_dims)\n", + " cuda_init_time = time.time() - start_time\n", + " implementations['CUDA'] = {\n", + " 'model': puzzle_cuda,\n", + " 'init_time': cuda_init_time,\n", + " 'device': 'CUDA'\n", + " }\n", + " print(f\" Initialization time: {cuda_init_time:.3f}s\")\n", + " print(f\" šŸ† CUDA speedup in init: {pytorch_init_time/cuda_init_time:.2f}x\")\n", + " COMPARE_IMPLEMENTATIONS = True\n", + " except RuntimeError as e:\n", + " print(f\" āŒ CUDA extension not compiled: {e}\")\n", + " print(\" šŸ”§ To enable CUDA acceleration:\")\n", + " print(\" - Run: cd puzzle_sim_cuda\")\n", + " print(\" - Then: make build\")\n", + " print(\" - Or: python build.py\")\n", + " COMPARE_IMPLEMENTATIONS = False\n", + " cuda_available = False\n", + "\n", + "print(f\"\\nšŸ“Š Available implementations: {list(implementations.keys())}\")" + ] }, { + "cell_type": "code", + "execution_count": 3, + "id": "c756c214a29de5f5", "metadata": { "ExecuteTime": { "end_time": "2024-11-29T16:27:54.300859Z", "start_time": "2024-11-29T16:27:54.146782Z" } }, - "cell_type": "code", - "source": "utils.plot_image_tensor_row(test_images, test_image_names)", - "id": "c756c214a29de5f5", "outputs": [ { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 3 + "source": [ + "utils.plot_image_tensor_row(test_images, test_image_names)" + ] }, { + "cell_type": "code", + "execution_count": 4, + "id": "500eeed35e8bccbe", "metadata": { "ExecuteTime": { "end_time": "2024-11-29T16:28:03.972828Z", "start_time": "2024-11-29T16:28:03.958778Z" } }, - "cell_type": "code", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "šŸ–¼ļø Selected test image: 00007.png\n", + " Shape: torch.Size([3, 416, 628])\n", + " Device: cuda:0\n", + "\n", + "šŸ”„ Running PyTorch implementation...\n", + " ā±ļø Inference time: 12.9ms\n", + " šŸ“ Output shape: torch.Size([416, 628])\n", + " šŸ“Š Value range: [0.6773, 0.9653]\n" + ] + } + ], "source": [ "# select one of the test images\n", "selected = \"00007.png\"\n", "test_image = test_images[np.argwhere(np.array(test_image_names) == selected)[0][0]]\n", "\n", - "sim = puzzle(test_image)" - ], - "id": "500eeed35e8bccbe", - "outputs": [], - "execution_count": 5 + "print(f\"šŸ–¼ļø Selected test image: {selected}\")\n", + "print(f\" Shape: {test_image.shape}\")\n", + "print(f\" Device: {test_image.device}\")\n", + "\n", + "# Run inference with all available implementations\n", + "results = {}\n", + "\n", + "for impl_name, impl_info in implementations.items():\n", + " print(f\"\\nšŸ”„ Running {impl_name} implementation...\")\n", + " model = impl_info['model']\n", + " \n", + " # Warm up (for fair timing)\n", + " with torch.no_grad():\n", + " _ = model(test_image)\n", + " \n", + " # Timed run\n", + " torch.cuda.synchronize() if torch.cuda.is_available() else None\n", + " start_time = time.perf_counter()\n", + " \n", + " with torch.no_grad():\n", + " similarity_map = model(test_image)\n", + " \n", + " torch.cuda.synchronize() if torch.cuda.is_available() else None\n", + " inference_time = time.perf_counter() - start_time\n", + " \n", + " results[impl_name] = {\n", + " 'similarity_map': similarity_map,\n", + " 'inference_time': inference_time,\n", + " 'shape': similarity_map.shape,\n", + " 'range': (similarity_map.min().item(), similarity_map.max().item()),\n", + " 'device': similarity_map.device\n", + " }\n", + " \n", + " print(f\" ā±ļø Inference time: {inference_time*1000:.1f}ms\")\n", + " print(f\" šŸ“ Output shape: {similarity_map.shape}\")\n", + " print(f\" šŸ“Š Value range: [{similarity_map.min():.4f}, {similarity_map.max():.4f}]\")\n", + "\n", + "# Performance comparison\n", + "if len(results) > 1:\n", + " pytorch_time = results['PyTorch']['inference_time']\n", + " cuda_time = results['CUDA']['inference_time']\n", + " speedup = pytorch_time / cuda_time\n", + " print(f\"\\nšŸ† Performance Summary:\")\n", + " print(f\" PyTorch: {pytorch_time*1000:.1f}ms\")\n", + " print(f\" CUDA: {cuda_time*1000:.1f}ms\")\n", + " print(f\" Speedup: {speedup:.2f}x\")" + ] }, { + "cell_type": "code", + "execution_count": 5, + "id": "1c5293eff1cb3c5d", "metadata": { "ExecuteTime": { "end_time": "2024-11-29T16:28:05.832801Z", "start_time": "2024-11-29T16:28:05.674757Z" } }, - "cell_type": "code", - "source": [ - "utils.plot_image_tensor(test_image)\n", - "utils.plot_heatmap_tensor(sim)" - ], - "id": "1c5293eff1cb3c5d", "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "šŸ“Š Visualizing results from PyTorch implementation\n" + ] + }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, "output_type": "display_data" }, { "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 6 + "source": [ + "# Visualization\n", + "import matplotlib.pyplot as plt\n", + "\n", + "if len(results) == 1:\n", + " # Single implementation visualization\n", + " impl_name = list(results.keys())[0]\n", + " similarity_map = results[impl_name]['similarity_map']\n", + " \n", + " print(f\"šŸ“Š Visualizing results from {impl_name} implementation\")\n", + " utils.plot_image_tensor(test_image)\n", + " utils.plot_heatmap_tensor(similarity_map)\n", + " \n", + "else:\n", + " # Comparison visualization\n", + " fig, axes = plt.subplots(2, len(results) + 1, figsize=(5 * (len(results) + 1), 10))\n", + " \n", + " # Show test image in first column\n", + " img_np = test_image.squeeze().cpu().permute(1, 2, 0).numpy()\n", + " axes[0, 0].imshow(img_np)\n", + " axes[0, 0].set_title(\"Test Image\")\n", + " axes[0, 0].axis('off')\n", + " axes[1, 0].axis('off') # Empty space below test image\n", + " \n", + " # Show results from each implementation\n", + " for i, (impl_name, result) in enumerate(results.items()):\n", + " similarity_map = result['similarity_map'].cpu().numpy()\n", + " inference_time = result['inference_time']\n", + " \n", + " # Top row: similarity maps\n", + " im = axes[0, i + 1].imshow(similarity_map, cmap='jet')\n", + " axes[0, i + 1].set_title(f'{impl_name}\\n{inference_time*1000:.1f}ms')\n", + " axes[0, i + 1].axis('off')\n", + " plt.colorbar(im, ax=axes[0, i + 1], fraction=0.046, pad=0.04)\n", + " \n", + " # Bottom row: difference visualization (if more than one implementation)\n", + " if len(results) > 1 and i > 0:\n", + " # Compare with first implementation\n", + " first_result = list(results.values())[0]['similarity_map'].cpu().numpy()\n", + " diff = np.abs(similarity_map - first_result)\n", + " \n", + " im_diff = axes[1, i + 1].imshow(diff, cmap='hot')\n", + " axes[1, i + 1].set_title(f'|{impl_name} - {list(results.keys())[0]}|\\nMax diff: {diff.max():.4f}')\n", + " axes[1, i + 1].axis('off')\n", + " plt.colorbar(im_diff, ax=axes[1, i + 1], fraction=0.046, pad=0.04)\n", + " else:\n", + " axes[1, i + 1].axis('off')\n", + " \n", + " plt.tight_layout()\n", + " plt.show()\n", + " \n", + " # Accuracy comparison\n", + " if len(results) > 1:\n", + " impl_names = list(results.keys())\n", + " map1 = results[impl_names[0]]['similarity_map']\n", + " map2 = results[impl_names[1]]['similarity_map']\n", + " \n", + " max_diff = torch.max(torch.abs(map1 - map2)).item()\n", + " relative_error = max_diff / torch.max(torch.abs(map1)).item()\n", + " \n", + " print(f\"\\nšŸ” Accuracy Comparison:\")\n", + " print(f\" Maximum absolute difference: {max_diff:.6f}\")\n", + " print(f\" Relative error: {relative_error:.6f}\")\n", + " \n", + " if relative_error < 1e-3:\n", + " print(\" āœ… Results match within tolerance!\")\n", + " else:\n", + " print(\" āš ļø Large difference detected!\")" + ] }, { + "cell_type": "code", + "execution_count": 6, + "id": "609c170a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "šŸ”§ CUDA implementation not available - skipping advanced features testing\n", + "Install puzzle_sim_cuda to enable CUDA-specific benchmarks\n" + ] + } + ], + "source": [ + "# Advanced Benchmarking and Configuration Testing\n", + "\n", + "if COMPARE_IMPLEMENTATIONS and 'CUDA' in implementations:\n", + " print(\"šŸš€ Advanced CUDA Features Testing\")\n", + " print(\"=\" * 50)\n", + " \n", + " # Test different memory modes (CUDA-specific feature)\n", + " memory_modes = [\n", + " {'name': 'Memory-Save (stride=2)', 'mem_save': True, 'stride': 2},\n", + " {'name': 'Memory-Save (stride=4)', 'mem_save': True, 'stride': 4},\n", + " {'name': 'Memory-Save (stride=8)', 'mem_save': True, 'stride': 8},\n", + " {'name': 'Naive Mode', 'mem_save': False, 'stride': 4},\n", + " ]\n", + " \n", + " print(\"\\nšŸ’¾ Testing different memory modes...\")\n", + " cuda_model = implementations['CUDA']['model']\n", + " \n", + " memory_results = {}\n", + " for mode in memory_modes:\n", + " print(f\"\\nTesting {mode['name']}...\")\n", + " try:\n", + " torch.cuda.reset_peak_memory_stats()\n", + " \n", + " start_time = time.perf_counter()\n", + " with torch.no_grad():\n", + " result = cuda_model(test_image, mem_save=mode['mem_save'], stride=mode['stride'])\n", + " exec_time = time.perf_counter() - start_time\n", + " \n", + " peak_memory = torch.cuda.max_memory_allocated() / 1024**2 # MB\n", + " \n", + " memory_results[mode['name']] = {\n", + " 'time': exec_time,\n", + " 'memory': peak_memory,\n", + " 'result': result\n", + " }\n", + " \n", + " print(f\" ā±ļø Time: {exec_time*1000:.1f}ms\")\n", + " print(f\" šŸ§  Memory: {peak_memory:.1f}MB\")\n", + " \n", + " except Exception as e:\n", + " print(f\" āŒ Failed: {e}\")\n", + " \n", + " # Test different network architectures\n", + " print(\"\\nšŸ§  Testing different network architectures...\")\n", + " net_types = ['squeeze', 'alex', 'vgg']\n", + " \n", + " architecture_results = {}\n", + " for net_type in net_types:\n", + " print(f\"\\nTesting {net_type} network...\")\n", + " try:\n", + " # Create smaller test for speed\n", + " small_resize = (128, 128)\n", + " test_puzzle = PuzzleSimCUDA(priors, net_type=net_type, resize=small_resize)\n", + " \n", + " start_time = time.perf_counter()\n", + " with torch.no_grad():\n", + " result = test_puzzle(test_image)\n", + " exec_time = time.perf_counter() - start_time\n", + " \n", + " architecture_results[net_type] = {\n", + " 'time': exec_time,\n", + " 'result_shape': result.shape,\n", + " 'result_range': (result.min().item(), result.max().item())\n", + " }\n", + " \n", + " print(f\" ā±ļø Time: {exec_time*1000:.1f}ms\")\n", + " print(f\" šŸ“ Shape: {result.shape}\")\n", + " print(f\" šŸ“Š Range: [{result.min():.3f}, {result.max():.3f}]\")\n", + " \n", + " except Exception as e:\n", + " print(f\" āŒ {net_type} failed: {e}\")\n", + " \n", + " print(\"\\nšŸ“Š Architecture Performance Summary:\")\n", + " for net_type, result in architecture_results.items():\n", + " print(f\" {net_type:>8}: {result['time']*1000:>6.1f}ms\")\n", + "\n", + "else:\n", + " print(\"šŸ”§ CUDA implementation not available - skipping advanced features testing\")\n", + " print(\"Install puzzle_sim_cuda to enable CUDA-specific benchmarks\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4ce1fde3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "šŸŽÆ Performance Summary & Recommendations\n", + "============================================================\n", + "šŸ“ Single Implementation Results:\n", + " Implementation: PyTorch\n", + " Inference Time: 12.9ms\n", + " Status: āœ… Working correctly\n", + "\n", + "šŸ’” To enable CUDA acceleration and comparison:\n", + " 1. Navigate to: cd puzzle_sim_cuda\n", + " 2. Build extension: make build (or python build.py)\n", + " 3. Restart notebook and re-run cells\n", + "\n", + "šŸ”§ System Information:\n", + " PyTorch Version: 2.6.0+cu126\n", + " CUDA Available: True\n", + " CUDA Device: NVIDIA GeForce RTX 4090\n", + " CUDA Memory: 24.0GB\n", + "\n", + "āœØ Demo completed successfully!\n", + "Dataset: flowers | Test Image: 00007.png\n", + "Implementations tested: ['PyTorch']\n" + ] + } + ], + "source": [ + "# Summary and Recommendations\n", + "\n", + "print(\"šŸŽÆ Performance Summary & Recommendations\")\n", + "print(\"=\" * 60)\n", + "\n", + "if COMPARE_IMPLEMENTATIONS and 'CUDA' in results and 'PyTorch' in results:\n", + " # Overall performance comparison\n", + " pytorch_time = results['PyTorch']['inference_time']\n", + " cuda_time = results['CUDA']['inference_time']\n", + " total_speedup = pytorch_time / cuda_time\n", + " \n", + " print(f\"šŸ“ˆ Overall Performance Comparison:\")\n", + " print(f\" PyTorch Implementation: {pytorch_time*1000:>8.1f}ms\")\n", + " print(f\" CUDA Implementation: {cuda_time*1000:>8.1f}ms\") \n", + " print(f\" šŸš€ Total Speedup: {total_speedup:>8.2f}x\")\n", + " \n", + " # Performance rating\n", + " if total_speedup > 5:\n", + " print(\" šŸ† Excellent performance improvement!\")\n", + " recommendation = \"Use CUDA implementation for production workloads\"\n", + " elif total_speedup > 2:\n", + " print(\" āœ… Good performance improvement\")\n", + " recommendation = \"CUDA implementation recommended for most use cases\"\n", + " else:\n", + " print(\" āš ļø Modest improvement\")\n", + " recommendation = \"Consider PyTorch for simplicity, CUDA for larger datasets\"\n", + " \n", + " # Memory efficiency (if tested)\n", + " if 'memory_results' in locals() and memory_results:\n", + " print(f\"\\nšŸ’¾ Memory Efficiency:\")\n", + " best_memory = min(memory_results.values(), key=lambda x: x['memory'])\n", + " best_time = min(memory_results.values(), key=lambda x: x['time'])\n", + " \n", + " for mode_name in memory_results:\n", + " result = memory_results[mode_name]\n", + " marker = \"šŸ†\" if result == best_memory else \"āš”\" if result == best_time else \" \"\n", + " print(f\" {marker} {mode_name:<25}: {result['time']*1000:>6.1f}ms, {result['memory']:>6.1f}MB\")\n", + " \n", + " print(f\"\\nšŸ’” Recommendation: {recommendation}\")\n", + " \n", + "else:\n", + " print(\"šŸ“ Single Implementation Results:\")\n", + " impl_name = list(results.keys())[0] \n", + " inference_time = results[impl_name]['inference_time']\n", + " print(f\" Implementation: {impl_name}\")\n", + " print(f\" Inference Time: {inference_time*1000:.1f}ms\")\n", + " print(f\" Status: {'āœ… Working correctly' if len(results) > 0 else 'āŒ Issues detected'}\")\n", + " \n", + " if not cuda_available:\n", + " print(f\"\\nšŸ’” To enable CUDA acceleration and comparison:\")\n", + " print(f\" 1. Navigate to: cd puzzle_sim_cuda\")\n", + " print(f\" 2. Build extension: make build (or python build.py)\")\n", + " print(f\" 3. Restart notebook and re-run cells\")\n", + "\n", + "print(f\"\\nšŸ”§ System Information:\")\n", + "print(f\" PyTorch Version: {torch.__version__}\")\n", + "print(f\" CUDA Available: {torch.cuda.is_available()}\")\n", + "if torch.cuda.is_available():\n", + " print(f\" CUDA Device: {torch.cuda.get_device_name(0)}\")\n", + " print(f\" CUDA Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f}GB\")\n", + "\n", + "print(f\"\\nāœØ Demo completed successfully!\")\n", + "print(f\"Dataset: {dataset} | Test Image: {selected}\")\n", + "print(f\"Implementations tested: {list(implementations.keys())}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5685058a605f50f9", "metadata": { "ExecuteTime": { "end_time": "2024-11-29T15:59:21.915550Z", "start_time": "2024-11-29T15:59:21.899549Z" } }, - "cell_type": "code", - "source": "", - "id": "5685058a605f50f9", "outputs": [], - "execution_count": null + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "volprim", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.11.11" } }, "nbformat": 4, diff --git a/puzzle_sim_cuda/README.md b/puzzle_sim_cuda/README.md new file mode 100644 index 0000000..a8fed33 --- /dev/null +++ b/puzzle_sim_cuda/README.md @@ -0,0 +1,430 @@ +# PuzzleSim CUDA + +CUDA-accelerated implementation of PuzzleSim. + +It rewires the hot path of the reference PyTorch implementation +(`puzzle_sim.PuzzleSim`): + +* channel-wise L2 normalization and bilinear upsample are replaced by custom + CUDA kernels (2-4x and ~1-2x faster than the PyTorch ops respectively), +* the per-layer "similarity vs reference distribution + max" runs on + three back-ends selectable via a `precision=` argument: + * `"fp32"` - chunked `torch.matmul + max` over packed reference features. + Hardest to beat numerically; default when the GPU does not support + tensor cores. + * `"tf32"` (default on `sm_80+`) - a custom WMMA kernel that fuses GEMM + with the row-wise max so the full `(qHW x K)` score matrix (several GB + on the largest scenarios) never has to hit DRAM. + * `"fp16"` - same kernel, half-precision A/B fragments. +* an optional `implementation="fused"` mode (SqueezeNet only for now) that + collapses the entire pipeline - scaling-free backbone + L2 normalize + + sim_max + bilinear upsample + weighted sum - into a single C++ entrypoint + using cuDNN's fused conv+bias+ReLU op. Eliminates Python dispatch between + the eight Fire modules and the three layer taps; typically ~2x faster than + the kernel implementation on resized scenarios. + +The torchvision backbone is shared by both paths and is left untouched. + +## Requirements + +- CUDA-capable GPU, compute capability 7.0+ +- CUDA Toolkit 11.8+ +- PyTorch 1.13+ built with CUDA +- A C++ host compiler supported by your CUDA toolkit (MSVC 2017-2022 on + Windows, GCC 9-12 on Linux) + +## Build + +```bash +cd puzzle_sim_cuda +python build.py # build the extension in-place +python build.py --clean # rebuild from scratch +``` + +On Windows you must run from a "Developer Command Prompt for VS 2022" (or any +shell where `vcvars64.bat` has been executed) so the build can find `cl.exe`. + +## Usage + +The CUDA model has the same public API as `puzzle_sim.PuzzleSim`: + +```python +import torch +from puzzle_sim_cuda import PuzzleSimCUDA + +refs = torch.rand(20, 3, 256, 256, device='cuda') +img = torch.rand(1, 3, 256, 256, device='cuda') + +model = PuzzleSimCUDA(refs, net_type='squeeze', resize=(128, 128)) +similarity = model(img) # (256, 256) + +# Pick a precision explicitly: +model_tf32 = PuzzleSimCUDA(refs, precision='tf32') # default on sm_80+ +model_fp16 = PuzzleSimCUDA(refs, precision='fp16') +model_fp32 = PuzzleSimCUDA(refs, precision='fp32') # strict numerical mode + +# Fully fused pipeline (SqueezeNet only): one C++ call per forward, no Python +# dispatch between backbone layers or sim_max steps. +from puzzle_sim_cuda import PuzzleSimCUDAFused +fused = PuzzleSimCUDAFused(refs, precision='tf32') +similarity = fused(img) +``` + +For a drop-in replacement of the reference, use the `PuzzleSim` factory: + +```python +from puzzle_sim_cuda import PuzzleSim +model = PuzzleSim(refs, net_type='squeeze', use_cuda=True) + +# or the fused pipeline +model = PuzzleSim(refs, net_type='squeeze', implementation='fused') +``` + +If `use_cuda=False` or the extension is not built, the factory falls back to +the original PyTorch implementation. The `precision=` argument is forwarded +to the CUDA path. `implementation='fused'` is squeeze-only; for other +backbones it silently falls back to the kernel implementation. + +## Choosing a mode + +There are two independent knobs. Both default to the fastest *broadly safe* +option, so most users never need to touch them. + +### `implementation` - how the pipeline is orchestrated + +| value | what it does | backbones | speed | +|-------|--------------|-----------|-------| +| `"kernel"` (default) | Python drives the torchvision backbone and calls the CUDA kernels once per tapped layer. | squeeze, alex, vgg | baseline CUDA path | +| `"fused"` | One C++ call runs the *entire* SqueezeNet pipeline (backbone via cuDNN's fused conv+bias+ReLU, then the normalize / sim_max / upsample kernels) with no Python between layers. | squeeze only (auto-falls back to `"kernel"` otherwise) | **~1.1-2.5x faster than `"kernel"`** | + +### `precision` - the numeric mode of the `sim_max` contraction + +| value | kernel used | needs | error vs fp32 | +|-------|-------------|-------|---------------| +| `"tf32"` (default) | custom WMMA tensor-core kernel (16x16x8), FP32 accumulate | `sm_80+` (Ampere/Ada/Hopper) | ~1e-3 at the kernel level | +| `"fp16"` | custom WMMA tensor-core kernel (16x16x16), FP32 accumulate | `sm_70+` (Volta+) | ~5e-3 at the kernel level | +| `"fp32"` | chunked `torch.matmul + max` (cuBLAS) | any CUDA GPU | exact (reference) | + +If the GPU can't support the requested precision, or the extension isn't +built, the wrapper silently falls back to `"fp32"`. + +### Which should I pick? + +- **Just want it fast and correct?** Keep the defaults + (`implementation="kernel"`, `precision="tf32"`). +- **Running SqueezeNet (the paper default) and want the most speed?** Use + `implementation="fused"`. This is the single biggest lever - it removes the + per-layer Python/PyTorch dispatch entirely. +- **Need bit-stable, reproducible numbers** (e.g. regression baselines, + gradient checks)? Use `precision="fp32"`. It is *not* slower end-to-end (see + below) and is the most accurate. +- **Memory-constrained on a huge contraction?** `tf32`/`fp16` never + materialise the `(qHW x K)` score matrix, so they use less peak VRAM than + the chunked `fp32` path on the largest scenarios. +- **AlexNet / VGG backbone?** Only `implementation="kernel"` applies; the + factory falls back automatically. + +### Expected speedups + +Measured end-to-end on an RTX 4090 (CUDA 12.9, PyTorch 2.5.1) against the +PyTorch reference `puzzle_sim.PuzzleSim`, averaged over the real `garden` +scenarios (full table under [Benchmarks](#benchmarks)): + +| implementation | end-to-end vs PyTorch reference | +|----------------|----------------------------------| +| `kernel` | **1.4-1.6x** avg (up to ~2.1x) | +| `fused` | **2.6-2.9x** avg (up to ~4.6x) | + +Two things worth internalising: + +- **The `implementation` knob moves the needle; `precision` barely does.** + End-to-end time is dominated by the torchvision backbone, so swapping the + `sim_max` precision changes the *total* by only a few percent. `precision` + is best understood as an accuracy/VRAM knob, not a speed knob. (At the + *kernel* level, isolated from the backbone, `tf32`/`fp16` do speed up + `sim_max` by 2-9x on small/medium problems - it just gets amortised away.) +- **`fp32` is not the slow option.** cuBLAS' GEMM is exceptionally well tuned; + on the largest single contraction (`garden`, no resize) it actually beats + the custom tensor-core kernels. The custom kernels win on small/medium + problems and on memory traffic, not on the giant contraction. + +### Expected accuracy + +Max absolute error of the final similarity map (values in `[0, 1]`) versus the +strict `fp32` kernel path, measured on `garden` at `resize=(256, 256)`: + +| mode | max abs error vs fp32 | +|------|-----------------------| +| `kernel` / `fp32` | 0 (reference) | +| `kernel` / `tf32` | ~1.2e-4 | +| `kernel` / `fp16` | ~1.2e-4 | +| `fused` / `fp32` | ~1.6e-4 | +| `fused` / `fp16` / `tf32` | ~2.0e-4 | + +All modes agree with the reference to ~1e-4 on the final map. Note `tf32` and `fp16` land at nearly the +same end-to-end error: the dominant error source is the cuDNN backbone (whose +convolutions already use TF32 by default) and the bilinear resize, which swamp +the `sim_max` precision difference. The `fused` path carries a slightly larger +`fp32` error than the `kernel` path because `at::cudnn_convolution_relu` and +the standard `at::conv2d` path can pick different cuDNN convolution algorithms. + +To force bit-stable convolutions for a strict comparison, set +`torch.backends.cudnn.allow_tf32 = False`; the fused backbone features then +match torchvision to ~1e-7. + +## Use as a differentiable loss + +PuzzleSim is differentiable with respect to the **query image**, so you can use +it as a perceptual loss and optimise an image to match a reference +distribution. Both `implementation` modes support this: + +```python +import torch +from puzzle_sim_cuda import PuzzleSim + +refs = torch.rand(8, 3, 128, 128, device='cuda') # frozen reference set +model = PuzzleSim(refs, net_type='squeeze') # or implementation='fused' + +img = torch.rand(1, 3, 128, 128, device='cuda', requires_grad=True) +opt = torch.optim.Adam([img], lr=5e-2) + +for _ in range(150): + opt.zero_grad(set_to_none=True) + sim = model(img) # similarity map, higher == more similar + loss = -sim.mean() # maximise similarity == minimise this + loss.backward() # populates img.grad + opt.step() + with torch.no_grad(): + img.clamp_(0, 1) +``` + +A runnable end-to-end example (synthetic, `garden`, or your own image folder, +for either mode) lives in [`examples/loss_demo.py`](examples/loss_demo.py): + +```bash +python puzzle_sim_cuda/examples/loss_demo.py --implementation fused --steps 150 +``` + +How it works and what to expect: + +- **Only the query image gets gradients.** The backbone weights and the packed + reference features are frozen constants, exactly as in the forward metric. +- **The backward always uses an exact FP32 `sim_max`.** The tensor-core + (`tf32`/`fp16`) kernels are inference-only and have no backward, so whenever + the input requires grad the metric automatically routes the contraction + through the differentiable `matmul + max` path. The `precision` argument still + controls the *no-grad* inference path; it does not change gradient accuracy. +- **The fused mode delegates the backward.** Because the fused C++ pipeline + bypasses autograd, a grad-requiring forward transparently runs through a + kernel-mode model built from the same weights/reference. The fast, + single-call fused path is used whenever gradients are *not* required. +- **The fast inference path is untouched.** With no grad required (or under + `torch.no_grad()`) you get the exact same detached output and custom kernels + as before - the differentiable path only activates when the input carries + grad and grad is enabled. + +The gradients are verified two ways in `tests/test_grad.py`: a central +finite-difference check of the directional derivative (matches the analytic +gradient to <5%) and an Adam loop that provably reduces the loss. For a strict +`gradcheck`-style comparison, set `torch.backends.cudnn.allow_tf32 = False` so +the backbone convolutions are computed in exact FP32. + +## Tests + +```bash +# From the repo root +python -m pytest puzzle_sim_cuda/tests -v +``` + +The suite (112 tests) covers: + +- per-op correctness against an obvious PyTorch reference (normalize, pack, + sim-max, upsample) - `tests/test_kernels.py` +- end-to-end agreement with `puzzle_sim.PuzzleSim` across all backbones, + input shapes, with and without `resize` - `tests/test_puzzlesim.py` +- tensor-core precision modes vs the fp32 baseline with mode-aware tolerances + (fp32 1e-5, tf32 1e-3, fp16 5e-3) - `tests/test_tensor_cores.py` +- the fused implementation vs the kernel implementation at every precision, + plus factory dispatch and squeeze-only fallback - `tests/test_fused.py` +- differentiability of both modes: backward populates the query gradient, the + inference path stays detached, a finite-difference check of the directional + derivative, and an Adam loop that reduces the loss - `tests/test_grad.py` +- end-to-end agreement on the bundled `garden` real-image dataset - + `tests/test_real_data.py` +- edge cases: weights validation, reduction modes, reference cache, invalid + precision, etc. + +The real-data tests skip cleanly when `PuzzleSim-demo-data/samples/garden` +is not present. + +If you see pytest plugin-import failures unrelated to this package, set +`PYTEST_DISABLE_PLUGIN_AUTOLOAD=1` before running. + +## Benchmarks + +```bash +python puzzle_sim_cuda/benchmark.py # quick synthetic set +python puzzle_sim_cuda/benchmark.py --scenarios all # full synthetic sweep +python puzzle_sim_cuda/benchmark.py --scenarios real # real images (garden) +python puzzle_sim_cuda/benchmark.py --scenarios all+real # all of the above +python puzzle_sim_cuda/benchmark.py --precision all # fp32 + tf32 + fp16 side by side +python puzzle_sim_cuda/benchmark.py --implementation all # kernel + fused side by side +python puzzle_sim_cuda/benchmark.py --csv out.csv # also dump CSV +``` + +The benchmark reports, for each scenario: + +| column | meaning | +|---------------|---------------------------------------------------------------| +| `backbone_ms` | scaling + resize + torchvision backbone (shared by both) | +| `ref_total` | full PyTorch reference forward | +| `cuda_total` | full CUDA forward | +| `ref_core` | `ref_total - backbone_ms` (the part the kernels replace) | +| `cuda_core` | `cuda_total - backbone_ms` | +| `total_sp` | `ref_total / cuda_total` | +| `core_sp` | `ref_core / cuda_core` (only the kernel work) | +| `ref_MB`/`cuda_MB` | peak GPU memory | + +`>>` in the `core_sp` column means the CUDA work is below the timing noise +floor relative to the backbone (i.e. effectively free). + +Sample numbers on an RTX 4090 (CUDA 12.9, PyTorch 2.5.1), from +`--scenarios real --implementation all --precision all`. `fused` rows are +absent for alex/vgg because that path is squeeze-only: + +``` +scenario impl prec backbone ref_total cuda_total ref_core cuda_core total_sp core_sp +garden(36x628x416) kernel fp32 1.45 12.70 10.82 11.25 9.37 1.17x 1.20x +garden(36x628x416) kernel tf32 1.45 12.70 14.60 11.25 13.15 0.87x 0.86x +garden(36x628x416) kernel fp16 1.45 12.70 11.76 11.25 10.30 1.08x 1.09x +garden(36x628x416) fused fp32 1.45 12.70 10.20 11.25 8.75 1.25x 1.29x +garden(36x628x416) fused tf32 1.45 12.70 13.43 11.25 11.98 0.95x 0.94x +garden(36x628x416) fused fp16 1.45 12.70 10.79 11.25 9.33 1.18x 1.21x +garden(...,resize=256) kernel fp32 1.56 3.70 2.41 2.14 0.85 1.54x 2.52x +garden(...,resize=256) kernel tf32 1.56 3.70 2.62 2.14 1.05 1.42x 2.03x +garden(...,resize=256) kernel fp16 1.56 3.70 2.42 2.14 0.85 1.53x 2.51x +garden(...,resize=256) fused fp32 1.56 3.70 1.31 2.14 0.00 2.82x >> +garden(...,resize=256) fused tf32 1.56 3.70 1.51 2.14 0.00 2.45x >> +garden(...,resize=256) fused fp16 1.56 3.70 1.29 2.14 0.00 2.87x >> +garden(...,resize=128) kernel fp32 1.64 3.48 1.90 1.83 0.26 1.83x 7.16x +garden(...,resize=128) kernel tf32 1.64 3.48 2.06 1.83 0.41 1.69x 4.44x +garden(...,resize=128) kernel fp16 1.64 3.48 2.08 1.83 0.44 1.67x 4.21x +garden(...,resize=128) fused fp32 1.64 3.48 0.76 1.83 0.00 4.58x >> +garden(...,resize=128) fused tf32 1.64 3.48 0.81 1.83 0.00 4.30x >> +garden(...,resize=128) fused fp16 1.64 3.48 0.84 1.83 0.00 4.16x >> +garden-alex(resize=256) kernel fp32 0.49 1.59 0.75 1.10 0.26 2.12x 4.18x +garden-alex(resize=256) kernel tf32 0.49 1.59 0.97 1.10 0.48 1.64x 2.29x +garden-alex(resize=256) kernel fp16 0.49 1.59 0.95 1.10 0.46 1.68x 2.40x +garden-vgg(resize=128) kernel fp32 1.00 3.35 2.34 2.35 1.35 1.43x 1.74x +garden-vgg(resize=128) kernel tf32 1.00 3.35 2.93 2.35 1.93 1.14x 1.22x +garden-vgg(resize=128) kernel fp16 1.00 3.35 2.12 2.35 1.12 1.58x 2.10x +``` + +Average end-to-end speedup vs the PyTorch reference over the real scenarios: + +| implementation | fp32 | tf32 | fp16 | +|----------------|------|------|------| +| `kernel` | 1.62x (max 2.12x) | 1.35x (max 1.69x) | 1.51x (max 1.68x) | +| `fused` | 2.88x (max 4.58x) | 2.56x (max 4.30x) | 2.74x (max 4.16x) | + +Head-to-head, `fused` is **1.06-2.54x faster than `kernel`** at the same +precision (avg 1.80x), and uses noticeably less peak VRAM (e.g. 3.0 GB vs +4.0-4.4 GB on `garden` with no resize) because it keeps no PyTorch +intermediates between layers. + +Notes: + +- On Windows the GPU is shared with the display (WDDM), so per-sample times + jitter heavily (5-15% run to run). The benchmark uses CUDA events and + reports the best of N runs - the only signal that is stable. +- The largest scenario (`garden(36x628x416)`, no resize) is bound by the + similarity contraction itself - 256 channels x 36 references x + 628x416 ~ 150k reference pixels. cuBLAS' chunked FP32 path is genuinely + hard to beat there (vendor library, two decades of tuning), and the + tensor-core kernels pay a small DRAM round-trip cost for their per-block + partial maxes; on this one scenario `tf32`/`fp16` actually lag `fp32`. The + custom kernels win on the smaller / resized scenarios and on peak memory. +- End-to-end, the `precision` choice is nearly speed-neutral because the + shared torchvision backbone dominates the total. The big lever is + `implementation`: `fused` removes all per-layer Python dispatch. +- The TF32/FP16 path lights up tensor cores via `nvcuda::wmma` (16x16x8 for + TF32, 16x16x16 for FP16). When the requested precision is not supported + by the device (e.g. TF32 below `sm_80`), the wrapper silently falls back + to `fp32`. + +## Layout + +``` +puzzle_sim_cuda/ +ā”œā”€ā”€ src/ +ā”‚ ā”œā”€ā”€ kernels.cu # CUDA kernels (normalize, sim_max tensor-core, upsample) +ā”‚ ā”œā”€ā”€ puzzle_sim_cuda.cpp # PyTorch bindings + FusedSqueezeNet registration +ā”‚ ā””ā”€ā”€ fused_inference.cpp # FusedSqueezeNet: whole pipeline in one C++ call +ā”œā”€ā”€ puzzle_sim_cuda.py # kernel-path wrapper (PuzzleSimCUDA) + PuzzleSim factory +ā”œā”€ā”€ puzzle_sim_cuda_fused.py # fused-path wrapper (PuzzleSimCUDAFused) +ā”œā”€ā”€ __init__.py # package entry point +ā”œā”€ā”€ setup.py # setuptools build config +ā”œā”€ā”€ build.py # convenience wrapper around `python setup.py build_ext` +ā”œā”€ā”€ benchmark.py # head-to-head benchmark against the PyTorch reference +ā”œā”€ā”€ examples/ +ā”‚ ā””ā”€ā”€ loss_demo.py # optimise an image with PuzzleSim as a differentiable loss +ā”œā”€ā”€ requirements.txt # runtime + dev dependencies +ā”œā”€ā”€ tests/ # pytest correctness suite (incl. test_grad.py) +ā””ā”€ā”€ README.md +``` + +## What's inside + +Three CUDA kernels, a packing helper, and the fused C++ pipeline: + +1. `normalize_features` - channel-wise L2 normalize, one thread per spatial + location. Replaces + `feat / sqrt(eps + feat.pow(2).sum(dim=1, keepdim=True))`. Roughly 2-4x + faster than the PyTorch chain because the entire pipeline (squared sum, + `rsqrtf`, scale) is fused into a single kernel. + +2. `bilinear_upsample` - 2D bilinear upsample of a `(H, W)` similarity map. + Replaces the `nn.Upsample` call at the end of the forward. Faster than + `F.interpolate` for small inputs because there is no python-side dispatch + and the kernel is purpose-built for the 2D case. + +3. `pack_reference` - one-time layout transform. Reference features come + in as `(N, C, H, W)`; the contraction wants `(C, N*H*W)`. Doing this + once at construction and caching the result removes a per-call + `permute + reshape + contiguous`. + +4. `sim_max_tf32` / `sim_max_fp16` - WMMA tensor-core kernels that fuse + the `(Q.T @ R).max(dim=1)` contraction into a single pipeline. Each + block computes the max over a `(TILE_M=64) x (TILE_N=128)` sub-tile of + the score matrix using `wmma::mma_sync` (16x16x8 TF32 or 16x16x16 + FP16) accumulating in FP32 fragments, then writes a per-tile partial + max into a small staging buffer. A second small kernel reduces the + partials per query row. Net effect: the `(qHW x K)` score matrix is + never materialised in DRAM. The full FP32 fall-back stays available + via `precision="fp32"` and is still the most accurate path; it is also + often the fastest on the very largest scenarios because cuBLAS' GEMM + is exceptionally well tuned there. + +5. `FusedSqueezeNet` (C++ class in `src/fused_inference.cpp`) - holds + the SqueezeNet1.1 weights pre-extracted from torchvision and runs the + entire metric in a single C++ call. Convolutions go through + `at::cudnn_convolution_relu`, the C++ binding to cuDNN's fused + `cudnnConvolutionBiasActivationForward` (conv + bias + ReLU in one + shot). Max-pool uses `at::max_pool2d`. Once the backbone has produced + the three layer taps, the same `normalize_features` / `sim_max_*` / + `bilinear_upsample` kernels listed above are invoked back-to-back - + no Python on the per-layer hot path. Exposed in Python via + `PuzzleSimCUDAFused`. Squeeze-only for now; the same scaffolding will + carry AlexNet and VGG. + +The chunked `precision="fp32"` similarity contraction uses Python-side +`torch.matmul + max`. cuBLAS' tiled, register-blocked GEMM is hard to beat +on this workload; chunking along `K` keeps the transient score matrix +bounded - by default the per-step tile is sized to stay under ~256 MB +regardless of the reference count. + +Everything runs on PyTorch's current CUDA stream. + +## License + +Apache 2.0. Same as the parent project. diff --git a/puzzle_sim_cuda/__init__.py b/puzzle_sim_cuda/__init__.py new file mode 100644 index 0000000..7026bf4 --- /dev/null +++ b/puzzle_sim_cuda/__init__.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 +"""CUDA-accelerated PuzzleSim metric.""" + +from .puzzle_sim_cuda import CUDA_EXT_AVAILABLE, PuzzleSim, PuzzleSimCUDA +from .puzzle_sim_cuda_fused import PuzzleSimCUDAFused + +__version__ = "0.2.0" +__all__ = [ + "PuzzleSim", + "PuzzleSimCUDA", + "PuzzleSimCUDAFused", + "CUDA_EXT_AVAILABLE", +] + + +def get_version_info() -> dict: + """Return a dict with package, torch and CUDA version info.""" + import torch + + info = { + "package_version": __version__, + "cuda_extension_available": CUDA_EXT_AVAILABLE, + "torch_version": torch.__version__, + "cuda_available": torch.cuda.is_available(), + "cuda_device_count": torch.cuda.device_count() if torch.cuda.is_available() else 0, + } + if torch.cuda.is_available(): + info["cuda_device_name"] = torch.cuda.get_device_name(0) + info["cuda_capability"] = torch.cuda.get_device_capability(0) + return info diff --git a/puzzle_sim_cuda/benchmark.py b/puzzle_sim_cuda/benchmark.py new file mode 100644 index 0000000..2d884ca --- /dev/null +++ b/puzzle_sim_cuda/benchmark.py @@ -0,0 +1,548 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Benchmark suite for PuzzleSim CUDA against the PyTorch reference. + +The script reports: + +* ``backbone_only``: the cost of the torchvision backbone + scaling. This is + shared by both implementations and acts as an effective floor on total time. +* ``ref total`` / ``cuda total``: end-to-end forward pass on the reference and + CUDA implementations, including the backbone. +* ``ref core`` / ``cuda core``: end-to-end minus the backbone cost - this is + the portion that the CUDA kernels are actually replacing. +* ``total speedup``: ref/cuda for end-to-end time. +* ``core speedup``: ref-core/cuda-core - the meaningful number for the kernel + work itself. + +Run with ``python benchmark.py``. Use ``--scenarios all`` for a larger sweep, +``--csv path.csv`` to dump results, ``--reps N`` to change timing samples. +""" + +from __future__ import annotations + +import argparse +import csv +import os +import sys +import time +from dataclasses import dataclass, asdict +from typing import Callable, List, Optional, Tuple + +import torch + +# Allow running this script from anywhere. We need: +# * ``_REPO_ROOT`` on sys.path so ``import puzzle_sim`` (reference impl) +# resolves AND ``import puzzle_sim_cuda`` resolves to the *package* +# (not the inner module of the same name); +# * ``_PKG_DIR`` on sys.path so the ``puzzle_sim_cuda_ext`` C++ extension +# - which lives inside the package directory - is importable. +# Order matters: _REPO_ROOT must come first so the package wins. We insert +# _PKG_DIR first then _REPO_ROOT so the final layout is [_REPO_ROOT, _PKG_DIR, ...]. +_REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) +_PKG_DIR = os.path.dirname(os.path.abspath(__file__)) +for p in (_PKG_DIR, _REPO_ROOT): + if p not in sys.path: + sys.path.insert(0, p) + + +def _cuda_sync() -> None: + if torch.cuda.is_available(): + torch.cuda.synchronize() + + +def _bench(fn: Callable[[], object], reps: int, warmup: int) -> Tuple[float, float]: + """Return (best seconds, peak GPU MB) over ``reps`` runs. + + Uses ``torch.cuda.Event`` for device-side timing. We report the best + (minimum) sample because Windows WDDM and background GPU work routinely + add 100ms-class delays on top of the actual kernel work; the median is + not a stable signal of what the kernels themselves cost. The minimum + approximates the no-contention runtime - which is the meaningful number + when comparing two implementations. + """ + for _ in range(warmup): + fn() + _cuda_sync() + if torch.cuda.is_available(): + torch.cuda.reset_peak_memory_stats() + + samples: List[float] = [] + if torch.cuda.is_available(): + start = torch.cuda.Event(enable_timing=True) + end = torch.cuda.Event(enable_timing=True) + for _ in range(reps): + start.record() + fn() + end.record() + end.synchronize() + samples.append(start.elapsed_time(end) / 1000.0) + else: + for _ in range(reps): + t0 = time.perf_counter() + fn() + samples.append(time.perf_counter() - t0) + + best = min(samples) + peak_mb = ( + torch.cuda.max_memory_allocated() / 1024 / 1024 + if torch.cuda.is_available() else 0.0 + ) + return best, peak_mb + + +@dataclass +class ScenarioResult: + scenario: str + precision: str + implementation: str + backbone_ms: float + ref_total_ms: float + cuda_total_ms: float + ref_core_ms: float + cuda_core_ms: float + total_speedup: float + core_speedup: float + ref_peak_mb: float + cuda_peak_mb: float + + def as_row(self) -> List[str]: + # When cuda_core is well below the measurement noise floor (i.e. the + # CUDA work is essentially free compared to the backbone) the ratio is + # not meaningful - report '>=N' as a lower bound instead. + if self.cuda_core_ms < 0.05: + core_cell = f" >> " + else: + core_cell = f"{self.core_speedup:5.2f}x" + return [ + self.scenario, + self.implementation, + self.precision, + f"{self.backbone_ms:7.2f}", + f"{self.ref_total_ms:7.2f}", + f"{self.cuda_total_ms:7.2f}", + f"{self.ref_core_ms:7.2f}", + f"{self.cuda_core_ms:7.2f}", + f"{self.total_speedup:5.2f}x", + core_cell, + f"{self.ref_peak_mb:6.0f}", + f"{self.cuda_peak_mb:6.0f}", + ] + + +def _measure_backbone( + model, + img: torch.Tensor, + resize: Optional[Tuple[int, int]], + reps: int, + warmup: int, +) -> float: + """Time the scaling + (optional) resize + backbone forward. + + Both implementations share this code path, so this measurement is + representative of the per-call backbone cost in the full forward. + The caller is expected to pass a model whose backbone has already been + exercised at least once (cuDNN tunes its kernels on first input shape). + """ + from puzzle_sim import _resize_tensor as torch_resize + + def go(): + with torch.no_grad(): + x = 2 * img - 1 + x = model.scaling_layer(x) + if resize is not None: + x = torch_resize(x, size=resize, align_corners=True) + model.net.forward(x) + t, _ = _bench(go, reps=reps, warmup=warmup) + return t * 1000 + + +def _load_dataset(name: str, device: str) -> Optional[Tuple[torch.Tensor, torch.Tensor]]: + """Load a sample dataset from ``PuzzleSim-demo-data/samples/``. + + Returns ``(priors, tests)`` or ``None`` if the data is unavailable. + """ + from pathlib import Path + base = Path(_REPO_ROOT) / "PuzzleSim-demo-data" / "samples" / name + if not (base / "prior").is_dir() or not (base / "test").is_dir(): + return None + from PIL import Image + import torchvision.transforms.functional as TF + + def _load_dir(p: "Path"): + names = sorted(x for x in p.iterdir() if x.suffix.lower() == ".png") + imgs = [TF.to_tensor(Image.open(x).convert("RGB")).unsqueeze(0) for x in names] + return torch.cat(imgs, dim=0) + + priors = _load_dir(base / "prior").to(device) + tests = _load_dir(base / "test").to(device) + return priors, tests + + +def run_scenario( + name: str, + num_refs: int, + ref_hw: Tuple[int, int], + test_hw: Tuple[int, int], + net_type: str = "squeeze", + resize: Optional[Tuple[int, int]] = None, + reps: int = 20, + warmup: int = 3, + precisions: Tuple[str, ...] = ("tf32",), + implementations: Tuple[str, ...] = ("kernel",), +) -> List[ScenarioResult]: + refs = torch.rand(num_refs, 3, *ref_hw, device="cuda") + img = torch.rand(1, 3, *test_hw, device="cuda") + + return _run_pair( + name, refs, img, net_type=net_type, resize=resize, + reps=reps, warmup=warmup, precisions=precisions, + implementations=implementations, + ) + + +def _make_cuda_model(impl: str, refs: torch.Tensor, net_type: str, + resize: Optional[Tuple[int, int]], precision: str): + """Construct a CUDA model for the given implementation choice. + + ``impl='fused'`` only supports the SqueezeNet backbone today; for any + other ``net_type`` the call returns ``None`` so the caller can skip the + fused row. + """ + from puzzle_sim_cuda import PuzzleSimCUDA, PuzzleSimCUDAFused + + if impl == "kernel": + return PuzzleSimCUDA(refs, net_type=net_type, resize=resize, precision=precision) + if impl == "fused": + if net_type != "squeeze": + return None + return PuzzleSimCUDAFused(refs, resize=resize, precision=precision) + raise ValueError(f"Unknown implementation: {impl!r}") + + +def _run_pair( + name: str, + refs: torch.Tensor, + img: torch.Tensor, + net_type: str, + resize: Optional[Tuple[int, int]], + reps: int, + warmup: int, + precisions: Tuple[str, ...], + implementations: Tuple[str, ...] = ("kernel",), +) -> List[ScenarioResult]: + """Benchmark a reference/CUDA model pair across implementations + precisions. + + Reference is timed once (it does not have a precision/implementation + setting). For each (implementation, precision) pair, the CUDA model is + built fresh, warmed, then timed. The backbone measurement is shared + across all CUDA configurations. + """ + from puzzle_sim import PuzzleSim as RefPuzzleSim + from puzzle_sim_cuda import PuzzleSimCUDA + + ref_model = RefPuzzleSim(refs, net_type=net_type, resize=resize).to(refs.device).eval() + + # Warm and time the backbone once (same architecture across precisions). + warm_cuda = PuzzleSimCUDA(refs, net_type=net_type, resize=resize, precision="fp32") + with torch.no_grad(): + for _ in range(warmup): + ref_model(img) + warm_cuda(img) + _cuda_sync() + + backbone_ms = _measure_backbone( + warm_cuda, img, resize=resize, reps=reps, warmup=2, + ) + + def run_ref(): + with torch.no_grad(): + ref_model(img) + ref_t, ref_mem = _bench(run_ref, reps=reps, warmup=2) + ref_ms = ref_t * 1000 + + out: List[ScenarioResult] = [] + for impl in implementations: + for precision in precisions: + cuda_model = _make_cuda_model(impl, refs, net_type, resize, precision) + if cuda_model is None: + # fused requested but unsupported for this net_type - skip silently. + continue + with torch.no_grad(): + for _ in range(warmup): + cuda_model(img) + _cuda_sync() + + def run_cuda(): + with torch.no_grad(): + cuda_model(img) + cuda_t, cuda_mem = _bench(run_cuda, reps=reps, warmup=2) + cuda_ms = cuda_t * 1000 + ref_core = max(0.0, ref_ms - backbone_ms) + cuda_core = max(0.0, cuda_ms - backbone_ms) + out.append(ScenarioResult( + scenario=name, + precision=precision, + implementation=impl, + backbone_ms=backbone_ms, + ref_total_ms=ref_ms, + cuda_total_ms=cuda_ms, + ref_core_ms=ref_core, + cuda_core_ms=cuda_core, + total_speedup=ref_ms / max(cuda_ms, 1e-6), + core_speedup=ref_core / max(cuda_core, 1e-6), + ref_peak_mb=ref_mem, + cuda_peak_mb=cuda_mem, + )) + return out + + +QUICK_SCENARIOS = [ + dict(name="5x64", num_refs=5, ref_hw=(64, 64), test_hw=(64, 64)), + dict(name="10x128", num_refs=10, ref_hw=(128, 128), test_hw=(128, 128)), + dict(name="20x256(resize=128)", num_refs=20, ref_hw=(256, 256), test_hw=(256, 256), resize=(128, 128)), +] + + +FULL_SCENARIOS = QUICK_SCENARIOS + [ + dict(name="50x128", num_refs=50, ref_hw=(128, 128), test_hw=(128, 128)), + dict(name="50x256(resize=128)", num_refs=50, ref_hw=(256, 256), test_hw=(256, 256), resize=(128, 128)), + dict(name="10x256-alex", num_refs=10, ref_hw=(256, 256), test_hw=(256, 256), resize=(128, 128), net_type="alex"), + dict(name="10x256-vgg", num_refs=10, ref_hw=(256, 256), test_hw=(256, 256), resize=(128, 128), net_type="vgg"), +] + + +# Real-data scenarios run on the named demo dataset. They are skipped at +# runtime if the data is not present. +REAL_SCENARIOS = [ + dict(name="garden(36x628x416)", dataset="garden", resize=None, net_type="squeeze"), + dict(name="garden(36x628x416,resize=256)", dataset="garden", resize=(256, 256), net_type="squeeze"), + dict(name="garden(36x628x416,resize=128)", dataset="garden", resize=(128, 128), net_type="squeeze"), + dict(name="garden-alex(resize=256)", dataset="garden", resize=(256, 256), net_type="alex"), + dict(name="garden-vgg(resize=128)", dataset="garden", resize=(128, 128), net_type="vgg"), +] + + +_COL_WIDTHS = [34, 7, 6, 11, 9, 10, 8, 9, 8, 7, 7, 7] + + +def _print_header() -> None: + headers = [ + "scenario", "impl", "prec", "backbone_ms", "ref_total", "cuda_total", + "ref_core", "cuda_core", "total_sp", "core_sp", + "ref_MB", "cuda_MB", + ] + print(" ".join(h.ljust(w) for h, w in zip(headers, _COL_WIDTHS))) + print("-" * (sum(_COL_WIDTHS) + len(_COL_WIDTHS) * 2)) + + +def _print_result(r: ScenarioResult) -> None: + cells = r.as_row() + print(" ".join(c.ljust(w) for c, w in zip(cells, _COL_WIDTHS))) + + +def _run_real_scenario( + name: str, + dataset: str, + resize: Optional[Tuple[int, int]], + net_type: str, + reps: int, + warmup: int, + precisions: Tuple[str, ...], + implementations: Tuple[str, ...] = ("kernel",), +) -> Optional[List[ScenarioResult]]: + """Run a benchmark scenario on a real demo dataset. + + Returns ``None`` if the dataset is unavailable so the caller can skip. + """ + data = _load_dataset(dataset, "cuda") + if data is None: + return None + refs, tests = data + img = tests[0:1] + return _run_pair( + name, refs, img, net_type=net_type, resize=resize, + reps=reps, warmup=warmup, precisions=precisions, + implementations=implementations, + ) + + +def _parse_precisions(spec: str) -> Tuple[str, ...]: + """Parse a comma-separated precision spec. + + ``"all"`` expands to ``("fp32", "tf32", "fp16")``. Individual items must be + one of the supported precisions. + """ + if spec == "all": + return ("fp32", "tf32", "fp16") + valid = {"fp32", "tf32", "fp16"} + out: List[str] = [] + for tok in spec.split(","): + tok = tok.strip() + if tok not in valid: + raise SystemExit( + f"--precision: {tok!r} is not one of {sorted(valid)} (or 'all')" + ) + out.append(tok) + return tuple(out) + + +def _parse_implementations(spec: str) -> Tuple[str, ...]: + if spec == "all": + return ("kernel", "fused") + valid = {"kernel", "fused"} + out: List[str] = [] + for tok in spec.split(","): + tok = tok.strip() + if tok not in valid: + raise SystemExit( + f"--implementation: {tok!r} is not one of {sorted(valid)} (or 'all')" + ) + out.append(tok) + return tuple(out) + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "--scenarios", + choices=["quick", "all", "real", "all+real"], + default="quick", + help=( + "Which scenario set to run. 'quick' / 'all' use synthetic random " + "tensors; 'real' uses the demo datasets (garden); 'all+real' is " + "the union." + ), + ) + parser.add_argument( + "--precision", + type=str, + default="tf32", + help=( + "Comma-separated precisions to benchmark, or 'all' for fp32,tf32,fp16. " + "Each scenario is emitted as one row per precision." + ), + ) + parser.add_argument( + "--implementation", + type=str, + default="kernel", + help=( + "Comma-separated implementations to benchmark, or 'all' for " + "kernel,fused. 'fused' is only valid for net_type='squeeze' and " + "is silently skipped for other backbones." + ), + ) + parser.add_argument("--reps", type=int, default=15) + parser.add_argument("--warmup", type=int, default=5) + parser.add_argument("--csv", type=str, default=None, + help="Optional path to write the results table to.") + args = parser.parse_args() + + if not torch.cuda.is_available(): + print("CUDA not available.") + return 1 + + precisions = _parse_precisions(args.precision) + implementations = _parse_implementations(args.implementation) + + print(f"GPU: {torch.cuda.get_device_name(0)}") + print(f"CUDA capability: {torch.cuda.get_device_capability(0)}") + print(f"PyTorch: {torch.__version__}") + print(f"precisions: {', '.join(precisions)}") + print(f"implementations: {', '.join(implementations)}") + print() + + synthetic = [] + real = [] + if args.scenarios in ("quick",): + synthetic = QUICK_SCENARIOS + elif args.scenarios in ("all",): + synthetic = FULL_SCENARIOS + elif args.scenarios == "real": + real = REAL_SCENARIOS + elif args.scenarios == "all+real": + synthetic = FULL_SCENARIOS + real = REAL_SCENARIOS + + _print_header() + results: List[ScenarioResult] = [] + for sc in synthetic: + try: + rs = run_scenario(reps=args.reps, warmup=args.warmup, + precisions=precisions, implementations=implementations, + **sc) + except Exception as e: # noqa: BLE001 - want to keep going on per-scenario errors + print(f"{sc['name']:22s} FAILED: {e}") + continue + for r in rs: + results.append(r) + _print_result(r) + for sc in real: + try: + rs = _run_real_scenario(reps=args.reps, warmup=args.warmup, + precisions=precisions, implementations=implementations, + **sc) + except Exception as e: # noqa: BLE001 + print(f"{sc['name']:22s} FAILED: {e}") + continue + if rs is None: + print(f"{sc['name']:22s} SKIPPED (dataset {sc['dataset']!r} not available)") + continue + for r in rs: + results.append(r) + _print_result(r) + + if results: + # Group summary by (implementation, precision). + for impl in implementations: + for precision in precisions: + subset = [r for r in results + if r.precision == precision and r.implementation == impl] + if not subset: + continue + avg_total = sum(r.total_speedup for r in subset) / len(subset) + max_total = max(r.total_speedup for r in subset) + meaningful_core = [r for r in subset if r.cuda_core_ms >= 0.05] + tag = f"[{impl}/{precision}]" + print() + print(f"{tag} avg total speedup: {avg_total:.2f}x (max {max_total:.2f}x)") + if meaningful_core: + avg_core = sum(r.core_speedup for r in meaningful_core) / len(meaningful_core) + max_core = max(r.core_speedup for r in meaningful_core) + print( + f"{tag} avg core speedup: {avg_core:.2f}x (max {max_core:.2f}x, " + f"over {len(meaningful_core)}/{len(subset)} scenarios where cuda_core > 0.05ms)" + ) + + # Direct kernel vs fused comparison (only where both are present). + if "kernel" in implementations and "fused" in implementations: + print() + print("kernel vs fused (same precision, same scenario):") + by_key: dict[Tuple[str, str], dict[str, ScenarioResult]] = {} + for r in results: + by_key.setdefault((r.scenario, r.precision), {})[r.implementation] = r + ratios: List[float] = [] + for (scenario, precision), per in sorted(by_key.items()): + if "kernel" in per and "fused" in per: + k = per["kernel"].cuda_total_ms + f = per["fused"].cuda_total_ms + ratio = k / max(f, 1e-6) + ratios.append(ratio) + print(f" {scenario:38s} {precision:5s} kernel={k:6.2f}ms fused={f:6.2f}ms fused_sp={ratio:5.2f}x") + if ratios: + avg = sum(ratios) / len(ratios) + print(f" fused vs kernel: avg {avg:.2f}x, max {max(ratios):.2f}x, min {min(ratios):.2f}x") + + if args.csv: + with open(args.csv, "w", newline="") as f: + writer = csv.DictWriter(f, fieldnames=list(asdict(results[0]).keys()) if results else []) + writer.writeheader() + for r in results: + writer.writerow(asdict(r)) + print(f"\nWrote {args.csv}") + + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/puzzle_sim_cuda/build.py b/puzzle_sim_cuda/build.py new file mode 100644 index 0000000..c6ac5b5 --- /dev/null +++ b/puzzle_sim_cuda/build.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Convenience entry point for building the CUDA extension. + +This is a thin wrapper around ``python setup.py build_ext --inplace`` that +keeps the working directory pinned to the location of ``setup.py``. +""" + +import argparse +import os +import shutil +import subprocess +import sys + + +def _run(cmd: list[str]) -> int: + print("$", " ".join(cmd), flush=True) + return subprocess.call(cmd) + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--clean", action="store_true", + help="Remove build artifacts before building") + parser.add_argument("--verbose", action="store_true", + help="Verbose build output") + args = parser.parse_args() + + here = os.path.dirname(os.path.abspath(__file__)) + os.chdir(here) + + if args.clean: + for d in ("build", "dist"): + if os.path.exists(d): + shutil.rmtree(d) + print(f"removed {d}/") + + cmd = [sys.executable, "setup.py", "build_ext", "--inplace"] + if args.verbose: + cmd.append("--verbose") + rc = _run(cmd) + if rc != 0: + print("Build failed.", file=sys.stderr) + return rc + + print("\nBuild complete. Quick sanity check:") + rc = _run([sys.executable, "-c", + "import torch, puzzle_sim_cuda_ext as e; " + "print('loaded:', sorted([s for s in dir(e) if not s.startswith('_')]))"]) + return rc + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/puzzle_sim_cuda/examples/loss_demo.py b/puzzle_sim_cuda/examples/loss_demo.py new file mode 100644 index 0000000..9bbe74c --- /dev/null +++ b/puzzle_sim_cuda/examples/loss_demo.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Use PuzzleSim as a differentiable perceptual loss. + +This optimises a *learnable image* so that its PuzzleSim similarity against a +reference distribution increases. The backbone weights and the reference are +frozen; gradients flow only to the image. It works with both the kernel and the +fused implementation (the fused model delegates the backward to an exact-FP32 +kernel path under the hood). + +Examples +-------- +Synthetic reference, kernel mode:: + + python loss_demo.py --steps 150 + +Fused mode against the garden demo set (if checked out):: + + python loss_demo.py --implementation fused --reference garden --steps 150 + +Optimise toward a folder of PNGs and save the result:: + + python loss_demo.py --reference path/to/imgs --out optimized.png +""" + +from __future__ import annotations + +import argparse +import os +import sys +from typing import Optional + +import torch + +# [_REPO_ROOT, _PKG_DIR] so ``puzzle_sim`` + the ``puzzle_sim_cuda`` *package* +# resolve, and the co-located C++ extension is importable. See benchmark.py. +_REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) +_PKG_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) +for p in (_PKG_DIR, _REPO_ROOT): + if p not in sys.path: + sys.path.insert(0, p) + + +def _synthetic_reference(n: int, size: int, device: str) -> torch.Tensor: + """A few smooth low-frequency colour fields - cheap, structured targets.""" + torch.manual_seed(1234) + ys = torch.linspace(0, 1, size, device=device) + xs = torch.linspace(0, 1, size, device=device) + gy, gx = torch.meshgrid(ys, xs, indexing="ij") + refs = [] + for i in range(n): + fx, fy = 1.0 + 2.0 * i, 1.5 + 1.5 * i + r = 0.5 + 0.5 * torch.sin(2 * torch.pi * (fx * gx + 0.1 * i)) + g = 0.5 + 0.5 * torch.sin(2 * torch.pi * (fy * gy + 0.2 * i)) + b = 0.5 + 0.5 * torch.cos(2 * torch.pi * (fx * gx + fy * gy)) + refs.append(torch.stack([r, g, b], dim=0)) + return torch.stack(refs, dim=0).clamp(0, 1) + + +def _load_image_folder(path: str, size: int, device: str) -> Optional[torch.Tensor]: + try: + from PIL import Image + import torchvision.transforms.functional as TF + except ImportError: + print("[warn] PIL/torchvision not available; cannot load images.") + return None + exts = {".png", ".jpg", ".jpeg", ".bmp"} + files = sorted(f for f in os.listdir(path) if os.path.splitext(f)[1].lower() in exts) + if not files: + return None + imgs = [] + for f in files: + im = Image.open(os.path.join(path, f)).convert("RGB").resize((size, size)) + imgs.append(TF.to_tensor(im)) + return torch.stack(imgs, dim=0).to(device) + + +def _resolve_reference(name: str, n: int, size: int, device: str) -> torch.Tensor: + if name == "synthetic": + return _synthetic_reference(n, size, device) + if name == "garden": + garden = os.path.join(_REPO_ROOT, "PuzzleSim-demo-data", "samples", "garden", "prior") + loaded = _load_image_folder(garden, size, device) if os.path.isdir(garden) else None + if loaded is None: + print("[warn] garden demo data not found; using synthetic reference.") + return _synthetic_reference(n, size, device) + return loaded + loaded = _load_image_folder(name, size, device) + if loaded is None: + raise SystemExit(f"No usable images found at {name!r}") + return loaded + + +def _build_model(implementation: str, reference: torch.Tensor, precision: str): + from puzzle_sim_cuda import PuzzleSim + + return PuzzleSim( + reference, + net_type="squeeze", + implementation=implementation, + precision=precision, + ) + + +def _save_image(img: torch.Tensor, path: str) -> None: + try: + import torchvision.utils as vutils + except ImportError: + print(f"[warn] torchvision not available; cannot save {path}.") + return + vutils.save_image(img.clamp(0, 1), path) + print(f"saved {path}") + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("--implementation", choices=["kernel", "fused"], default="kernel") + parser.add_argument("--precision", choices=["fp32", "tf32", "fp16"], default="tf32", + help="Inference precision. The backward always uses exact FP32.") + parser.add_argument("--reference", default="synthetic", + help="'synthetic', 'garden', or a folder of images.") + parser.add_argument("--num-refs", type=int, default=4, help="Synthetic reference count.") + parser.add_argument("--size", type=int, default=128) + parser.add_argument("--steps", type=int, default=150) + parser.add_argument("--lr", type=float, default=5e-2) + parser.add_argument("--layers", type=int, nargs="+", default=[2, 3, 4]) + parser.add_argument("--out", default=None, help="Optional path to save the optimised image.") + parser.add_argument("--device", default="cuda") + args = parser.parse_args() + + if args.device == "cuda" and not torch.cuda.is_available(): + raise SystemExit("CUDA is not available; pass --device cpu (kernel mode only).") + + reference = _resolve_reference(args.reference, args.num_refs, args.size, args.device) + print(f"reference: {tuple(reference.shape)} on {reference.device}") + + model = _build_model(args.implementation, reference, args.precision) + + img = torch.rand(1, 3, args.size, args.size, device=args.device, requires_grad=True) + if args.out: + _save_image(img.detach()[0], args.out.replace(".", "_init.", 1)) + + opt = torch.optim.Adam([img], lr=args.lr) + layers = tuple(args.layers) + weights = tuple([1.0 / len(layers)] * len(layers)) + + print(f"\nOptimising {args.implementation}/{args.precision} for {args.steps} steps " + f"(layers={layers})\n" + "-" * 52) + first = None + for step in range(args.steps): + opt.zero_grad(set_to_none=True) + sim = model(img, layers=layers, weights=weights) + loss = -sim.mean() # maximise similarity == minimise negative similarity + loss.backward() + opt.step() + with torch.no_grad(): + img.clamp_(0.0, 1.0) + if step == 0: + first = loss.item() + if step % max(1, args.steps // 10) == 0 or step == args.steps - 1: + print(f" step {step:4d} loss={loss.item():+.5f} mean_sim={sim.mean().item():.5f}") + + last = loss.item() + print("-" * 52) + print(f"loss: {first:+.5f} -> {last:+.5f} (reduced by {first - last:.5f})") + assert last < first, "optimisation failed to reduce the loss" + + if args.out: + _save_image(img.detach()[0], args.out) + + +if __name__ == "__main__": + main() diff --git a/puzzle_sim_cuda/puzzle_sim_cuda.py b/puzzle_sim_cuda/puzzle_sim_cuda.py new file mode 100644 index 0000000..b811c37 --- /dev/null +++ b/puzzle_sim_cuda/puzzle_sim_cuda.py @@ -0,0 +1,432 @@ +# SPDX-License-Identifier: Apache-2.0 +"""High-level PuzzleSim implementation backed by CUDA. + +Mirrors the API of ``puzzle_sim.PuzzleSim`` but: + +* swaps in custom CUDA kernels for L2 normalization, bilinear upsample, and + a fused tensor-core ``sim_max`` (GEMM + per-row max in a single kernel), +* picks the ``sim_max`` precision at construction time: + - ``"tf32"`` (default): tensor-core kernel, ~1e-3 abs error vs FP32, + - ``"fp16"``: tensor-core kernel with FP16 inputs / FP32 accumulator, + ~5e-3 abs error, fastest, + - ``"fp32"``: chunked ``torch.matmul + max`` fallback for strict-precision + tests or older GPUs without tensor cores, +* packs reference features once at construction into the layout the + contraction expects, so the per-query cost is just one backbone forward + plus one ``sim_max`` per layer. +""" + +from __future__ import annotations + +import contextlib +import os +import sys +from typing import Dict, List, Literal, Optional, Tuple + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from puzzle_sim import Alexnet, ScalingLayer, SqueezeNet, Vgg16, _resize_tensor + + +# The compiled extension is built next to this package. Make sure its directory +# is importable so ``import puzzle_sim_cuda_ext`` resolves regardless of how the +# package was first imported (e.g. before a test ``conftest`` has extended +# ``sys.path``). Using the single top-level name everywhere is important: the +# pybind11 module is single-phase init and must not be loaded under two names. +_PKG_DIR = os.path.dirname(os.path.abspath(__file__)) +if _PKG_DIR not in sys.path: + sys.path.insert(0, _PKG_DIR) + +try: + import puzzle_sim_cuda_ext as _ext # type: ignore[import-not-found] + CUDA_EXT_AVAILABLE = True +except ImportError: # pragma: no cover - exercised via fallback path + _ext = None + CUDA_EXT_AVAILABLE = False + + +Precision = Literal["fp32", "tf32", "fp16"] +_VALID_PRECISIONS = ("fp32", "tf32", "fp16") + + +_NET_CHANNELS: Dict[str, List[int]] = { + "squeeze": [64, 128, 256, 384, 384, 512, 512], + "alex": [64, 192, 384, 256, 256], + "vgg": [64, 128, 256, 512, 512], + "vgg16": [64, 128, 256, 512, 512], +} + + +def _make_backbone(net_type: str) -> nn.Module: + if net_type in ("vgg", "vgg16"): + return Vgg16(pretrained=True, requires_grad=False) + if net_type == "alex": + return Alexnet(pretrained=True, requires_grad=False) + if net_type == "squeeze": + return SqueezeNet(pretrained=True, requires_grad=False) + raise ValueError(f"Unknown net_type: {net_type!r}") + + +def _grad_active(img: torch.Tensor) -> bool: + """True when autograd should record ops for ``img``. + + The custom CUDA kernels have no backward, so the differentiable code paths + only kick in when grad is enabled *and* the input is part of a graph that + requires it (e.g. a learnable image used as a perceptual loss). + """ + return ( + torch.is_grad_enabled() + and isinstance(img, torch.Tensor) + and img.requires_grad + ) + + +def _normalize_features(features: torch.Tensor, eps: float = 1e-8) -> torch.Tensor: + """Channel-wise L2 normalization. + + Uses the CUDA kernel when available and applicable; otherwise falls back to + differentiable PyTorch ops (also used whenever ``features`` carries grad, + since the kernel has no backward). + """ + if ( + features.is_cuda + and CUDA_EXT_AVAILABLE + and features.dtype == torch.float32 + and not features.requires_grad + ): + return _ext.normalize_features(features.contiguous(), eps) + norm = torch.sqrt(eps + features.pow(2).sum(dim=1, keepdim=True)) + return features / norm + + +def _pack_reference(refs: torch.Tensor) -> torch.Tensor: + """Transpose+flatten ``(N, C, H, W)`` references to ``(C, N*H*W)``. + + Done once at construction so the per-call ``sim_max`` does not need to + materialise a transposed view of refs every forward. + """ + if refs.is_cuda and CUDA_EXT_AVAILABLE and refs.dtype == torch.float32: + return _ext.pack_reference(refs.contiguous()) + N, C, H, W = refs.shape + return refs.transpose(0, 1).contiguous().reshape(C, N * H * W) + + +# Peak transient bytes per matmul chunk when computing scores. 256 MB keeps us +# well under typical 6-8 GB free VRAM after the backbone is loaded, and the +# tile is large enough that cuBLAS hits its high-throughput kernels. +_SCORE_CHUNK_BYTES = 256 * 1024 * 1024 + + +def _device_capability_at_least(major: int, minor: int = 0) -> bool: + if not torch.cuda.is_available(): + return False + cap = torch.cuda.get_device_capability() + return cap >= (major, minor) + + +def _validate_precision(precision: str) -> Precision: + if precision not in _VALID_PRECISIONS: + raise ValueError( + f"precision must be one of {_VALID_PRECISIONS!r}, got {precision!r}" + ) + return precision # type: ignore[return-value] + + +def _sim_max( + query_feats: torch.Tensor, + refs_packed: torch.Tensor, + query_hw: Tuple[int, int], + precision: Precision = "fp32", +) -> torch.Tensor: + """Per-pixel max similarity of ``query_feats`` against the packed refs. + + Dispatch: + * ``precision == "tf32"`` / ``"fp16"``: tensor-core kernel from the C++ + extension. ``refs_packed`` must match: FP32 for tf32, FP16 for fp16. + * ``precision == "fp32"``: chunked ``torch.matmul + max``. ``refs_packed`` + must be FP32. + + Args: + query_feats: ``(1, C, qH, qW)`` or ``(C, qH, qW)`` query features + (already L2 normalized). + refs_packed: ``(C, N*rH*rW)`` reference features in the correct dtype. + query_hw: ``(qH, qW)`` of the query. + precision: one of ``"fp32"``, ``"tf32"``, ``"fp16"``. + + Returns: + ``(qH, qW)`` similarity map (always FP32). + """ + if query_feats.dim() == 4: + query_feats = query_feats.squeeze(0) + + C, qH, qW = query_feats.shape + qHW = qH * qW + assert query_hw == (qH, qW) + query_packed = query_feats.reshape(C, qHW).contiguous() + + if ( + precision in ("tf32", "fp16") + and CUDA_EXT_AVAILABLE + and query_packed.is_cuda + and not query_packed.requires_grad + ): + if precision == "tf32": + assert refs_packed.dtype == torch.float32, ( + f"refs_packed must be float32 for tf32 sim_max, got {refs_packed.dtype}" + ) + return _ext.sim_max_tf32(query_packed, refs_packed, [qH, qW]) + # fp16 + assert refs_packed.dtype == torch.float16, ( + f"refs_packed must be float16 for fp16 sim_max, got {refs_packed.dtype}" + ) + return _ext.sim_max_fp16(query_packed.half(), refs_packed, [qH, qW]) + + # FP32 fallback via chunked matmul. Picks a K chunk such that the per-step + # score tile (qHW * chunk) stays under _SCORE_CHUNK_BYTES. + K = refs_packed.size(1) + bytes_per_element = query_packed.element_size() + max_chunk = max(1, _SCORE_CHUNK_BYTES // max(1, qHW * bytes_per_element)) + chunk = min(K, max_chunk) + + q_t = query_packed.transpose(0, 1) # (qHW, C); non-contig view is fine, cuBLAS handles it. + if chunk >= K: + scores = q_t @ refs_packed # (qHW, K) + sim_map = scores.max(dim=1).values + else: + sim_map = torch.full((qHW,), float("-inf"), + device=query_packed.device, + dtype=query_packed.dtype) + for k0 in range(0, K, chunk): + k1 = min(k0 + chunk, K) + partial = q_t @ refs_packed[:, k0:k1] # (qHW, chunk) + torch.maximum(sim_map, partial.max(dim=1).values, out=sim_map) + + return sim_map.reshape(qH, qW) + + +def _bilinear_upsample( + sim_map: torch.Tensor, + out_hw: Tuple[int, int], + align_corners: bool = True, +) -> torch.Tensor: + """Bilinear upsample a 2D ``(H, W)`` similarity map to ``out_hw``.""" + if ( + sim_map.is_cuda + and CUDA_EXT_AVAILABLE + and sim_map.dtype == torch.float32 + and sim_map.dim() == 2 + and not sim_map.requires_grad + ): + return _ext.bilinear_upsample(sim_map.contiguous(), list(out_hw), align_corners) + return F.interpolate( + sim_map.unsqueeze(0).unsqueeze(0), + size=out_hw, + mode="bilinear", + align_corners=align_corners, + ).squeeze(0).squeeze(0) + + +class PuzzleSimCUDA(nn.Module): + """CUDA-accelerated PuzzleSim metric. + + Compared to :class:`puzzle_sim.PuzzleSim`, this implementation: + + * Pre-packs reference features into the layout expected by the + contraction, so this preparation happens once instead of on every + forward. + * Uses custom CUDA kernels for channel-wise L2 normalization, bilinear + upsample, and (for ``precision != "fp32"``) the fused GEMM + max. + * Picks the ``sim_max`` precision via the ``precision`` argument. + + The backbone CNN is still PyTorch's torchvision model in eval mode; that + part of the pipeline is already cuDNN-backed. + + Args: + reference: ``(N, C, H, W)`` tensor with the reference distribution. + net_type: ``'squeeze'`` (default, as in the paper), ``'alex'`` or + ``'vgg'``. + resize: optional ``(H, W)`` to bilinearly resize inputs to before + running the backbone. + precision: one of ``"tf32"`` (default, sm_80+), ``"fp16"`` (sm_70+), + or ``"fp32"`` (chunked cuBLAS GEMM; works everywhere). + """ + + def __init__( + self, + reference: torch.Tensor, + net_type: Literal["alex", "vgg", "squeeze"] = "squeeze", + resize: Optional[Tuple[int, int]] = None, + precision: Precision = "tf32", + ) -> None: + super().__init__() + if net_type not in _NET_CHANNELS: + raise ValueError(f"Unknown net_type: {net_type!r}") + + precision = _validate_precision(precision) + if precision == "tf32" and not _device_capability_at_least(8): + # Tensor-core TF32 needs Ampere. Silently fall back to FP32. + precision = "fp32" + if precision == "fp16" and not _device_capability_at_least(7): + precision = "fp32" + if precision != "fp32" and not CUDA_EXT_AVAILABLE: + precision = "fp32" + + self.net_type = net_type + self.resize = resize + self.precision: Precision = precision + self.chns = _NET_CHANNELS[net_type] + self.L = len(self.chns) + self.device = reference.device + + self.net = _make_backbone(net_type).to(reference.device).eval() + self.scaling_layer = ScalingLayer().to(reference.device) + + for p in self.parameters(): + p.requires_grad = False + + self.reference = reference + # Cached, packed reference features. Filled lazily on first forward so + # we never run a 4090 backbone forward inside __init__ when the user + # might still be moving things around. ``_packed_refs`` always stores + # FP32 versions; ``_packed_refs_fp16`` is populated on demand. + self._packed_refs: Optional[Dict[int, torch.Tensor]] = None + self._packed_refs_fp16: Dict[int, torch.Tensor] = {} + self._ref_shapes: Optional[Dict[int, Tuple[int, int]]] = None + + # ------------------------------------------------------------------ + # Feature extraction + # ------------------------------------------------------------------ + def _scaled_input(self, img: torch.Tensor, normalize: bool) -> torch.Tensor: + if img.dim() == 3: + img = img.unsqueeze(0) + if normalize: + img = 2 * img - 1 + img = self.scaling_layer(img) + if self.resize is not None: + img = _resize_tensor(img, size=self.resize, align_corners=True) + return img + + def compute_features( + self, + img: torch.Tensor, + normalize: bool = False, + ) -> Dict[int, torch.Tensor]: + """Return normalized backbone features for ``img``. + + Gradients flow back to ``img`` when it requires grad and grad is enabled + (the backbone weights stay frozen). Otherwise the call runs under + ``no_grad`` and uses the fast custom kernels, exactly as before. + """ + img = img.to(self.device) + ctx = contextlib.nullcontext() if _grad_active(img) else torch.no_grad() + with ctx: + scaled = self._scaled_input(img, normalize) + outs = self.net.forward(scaled) + return {k: _normalize_features(outs[k]) for k in range(self.L)} + + def _ensure_reference_packed(self) -> None: + if self._packed_refs is not None: + return + with torch.no_grad(): + ref_feats = self.compute_features(self.reference, normalize=True) + self._packed_refs = {} + self._ref_shapes = {} + for k, feats in ref_feats.items(): + self._packed_refs[k] = _pack_reference(feats) + self._ref_shapes[k] = (feats.shape[2], feats.shape[3]) + + def _refs_for_layer(self, layer: int) -> torch.Tensor: + """Return packed refs for ``layer`` in the dtype matching ``self.precision``.""" + assert self._packed_refs is not None + if self.precision == "fp16": + cached = self._packed_refs_fp16.get(layer) + if cached is None: + cached = self._packed_refs[layer].half().contiguous() + self._packed_refs_fp16[layer] = cached + return cached + return self._packed_refs[layer] + + # ------------------------------------------------------------------ + # Forward + # ------------------------------------------------------------------ + def forward( + self, + img: torch.Tensor, + layers: Tuple[int, ...] = (2, 3, 4), + normalize: bool = True, + reduction: Literal["mean", "sum"] = "sum", + weights: Optional[Tuple[float, ...]] = (0.67, 0.2, 0.13), + ) -> torch.Tensor: + """Return a similarity map for ``img`` against the reference distribution.""" + if weights is not None and len(weights) != len(layers): + raise ValueError("Number of weights must match number of layers.") + + self._ensure_reference_packed() + assert self._packed_refs is not None and self._ref_shapes is not None + + if img.dim() == 3: + img = img.unsqueeze(0) + out_hw = img.shape[-2:] + + # When the query carries grad, compute sim_max in exact FP32 (the + # tensor-core kernels have no backward); references stay frozen. + differentiable = _grad_active(img) + query_feats = self.compute_features(img, normalize=normalize) + + sims: List[torch.Tensor] = [] + for i, layer in enumerate(layers): + q = query_feats[layer] + qH, qW = q.shape[2], q.shape[3] + if differentiable: + r = self._packed_refs[layer] + sim_map = _sim_max(q, r, (qH, qW), precision="fp32") + else: + r = self._refs_for_layer(layer) + sim_map = _sim_max(q, r, (qH, qW), precision=self.precision) + if weights is not None: + sim_map = sim_map * weights[i] + sims.append(_bilinear_upsample(sim_map, out_hw, align_corners=True)) + + result = torch.stack(sims, dim=0).sum(dim=0) + if reduction == "mean": + result = result / len(sims) + return result + + +def PuzzleSim( # noqa: N802 - keep parity with original API + reference: torch.Tensor, + net_type: Literal["alex", "vgg", "squeeze"] = "squeeze", + resize: Optional[Tuple[int, int]] = None, + use_cuda: bool = True, + precision: Precision = "tf32", + implementation: Literal["kernel", "fused"] = "kernel", +): + """Drop-in replacement for :class:`puzzle_sim.PuzzleSim`. + + When ``use_cuda`` is true *and* the CUDA extension is built *and* the + reference tensor is on a CUDA device, returns a :class:`PuzzleSimCUDA` + instance (``implementation='kernel'``) or :class:`PuzzleSimCUDAFused` + (``implementation='fused'``). Otherwise falls back to the original PyTorch + implementation. + + The fused implementation is currently only available for + ``net_type='squeeze'``; for other backbones it silently falls back to the + kernel implementation. + """ + if ( + use_cuda + and CUDA_EXT_AVAILABLE + and torch.cuda.is_available() + and reference.is_cuda + ): + if implementation == "fused" and net_type == "squeeze": + from .puzzle_sim_cuda_fused import PuzzleSimCUDAFused + return PuzzleSimCUDAFused(reference, resize=resize, precision=precision) + return PuzzleSimCUDA(reference, net_type=net_type, resize=resize, precision=precision) + from puzzle_sim import PuzzleSim as _RefPuzzleSim + return _RefPuzzleSim(reference, net_type=net_type, resize=resize) + + +__all__ = ["PuzzleSimCUDA", "PuzzleSim", "CUDA_EXT_AVAILABLE", "Precision"] diff --git a/puzzle_sim_cuda/puzzle_sim_cuda_fused.py b/puzzle_sim_cuda/puzzle_sim_cuda_fused.py new file mode 100644 index 0000000..ddef07a --- /dev/null +++ b/puzzle_sim_cuda/puzzle_sim_cuda_fused.py @@ -0,0 +1,245 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Fully fused C++ implementation of PuzzleSim over SqueezeNet1.1. + +Unlike :class:`puzzle_sim_cuda.PuzzleSimCUDA`, which orchestrates the per-layer +backbone / normalize / sim-max / upsample chain in Python, this class hands +the entire pipeline to a single C++ entrypoint. The C++ side owns: + +* the SqueezeNet weights (pre-extracted from torchvision once at construction), +* the cuDNN handle that backs ``at::cudnn_convolution_relu`` (the fused + conv + bias + ReLU kernel), +* the packed, cached reference features per layer, +* the tensor-core ``sim_max`` kernels from this extension. + +The only work that stays in Python is the (cheap) scaling layer + optional +input resize, plus turning the dict of weights into the order the C++ class +expects. Per forward, there is exactly one round-trip into C++. +""" + +from __future__ import annotations + +from typing import Dict, List, Literal, Optional, Tuple + +import torch +import torch.nn as nn + +from puzzle_sim import ScalingLayer, SqueezeNet, _resize_tensor + +# Reuse the exact module object the kernel path already imported (it also makes +# sure the package directory is on sys.path). Sharing the single instance avoids +# loading the single-phase pybind11 extension under two different names. +from .puzzle_sim_cuda import _ext, _grad_active + + +_HAVE_FUSED = _ext is not None and hasattr(_ext, "FusedSqueezeNet") + + +Precision = Literal["fp32", "tf32", "fp16"] +_VALID_PRECISIONS = ("fp32", "tf32", "fp16") + + +def _device_capability_at_least(major: int, minor: int = 0) -> bool: + if not torch.cuda.is_available(): + return False + cap = torch.cuda.get_device_capability() + return cap >= (major, minor) + + +def _extract_squeeze_weights(net: SqueezeNet) -> List[torch.Tensor]: + """Flatten the SqueezeNet1.1 backbone weights into the 50-tensor list + the C++ ``FusedSqueezeNet`` constructor expects. + + Layout (see ``src/fused_inference.cpp``): + [0] conv0.weight (64, 3, 3, 3) + [1] conv0.bias (64,) + [2..49] eight Fire modules, each contributing six tensors in order + squeeze.weight, squeeze.bias, + expand1x1.weight, expand1x1.bias, + expand3x3.weight, expand3x3.bias. + """ + weights: List[torch.Tensor] = [] + weights.append(net.slices[0][0].weight.detach().contiguous()) + weights.append(net.slices[0][0].bias.detach().contiguous()) + fires_seen = 0 + for s_idx in range(1, 7): + for m in net.slices[s_idx]: + if hasattr(m, "squeeze") and hasattr(m, "expand1x1") and hasattr(m, "expand3x3"): + weights.append(m.squeeze.weight.detach().contiguous()) + weights.append(m.squeeze.bias.detach().contiguous()) + weights.append(m.expand1x1.weight.detach().contiguous()) + weights.append(m.expand1x1.bias.detach().contiguous()) + weights.append(m.expand3x3.weight.detach().contiguous()) + weights.append(m.expand3x3.bias.detach().contiguous()) + fires_seen += 1 + assert fires_seen == 8, f"Expected 8 Fire modules in SqueezeNet1.1, got {fires_seen}" + assert len(weights) == 50, f"Expected 50 weight tensors, got {len(weights)}" + return weights + + +class PuzzleSimCUDAFused(nn.Module): + """End-to-end fused PuzzleSim over SqueezeNet1.1. + + Numerically equivalent to :class:`puzzle_sim_cuda.PuzzleSimCUDA` with + ``net_type='squeeze'`` at the same ``precision``, but it bundles the + backbone forward, normalize, sim-max and upsample into one C++ call. + + Currently only the SqueezeNet backbone is supported; AlexNet/VGG will + follow the same pattern. + + Args: + reference: ``(N, 3, H, W)`` reference distribution. + resize: optional ``(H, W)`` target. Applied as in the reference + ``puzzle_sim`` implementation (``area`` mode when downscaling, + anti-aliased bilinear otherwise). + precision: one of ``"tf32"`` (default, sm_80+), ``"fp16"`` (sm_70+), + ``"fp32"``. Bound to the ``sim_max`` step; the cuDNN convolutions + silently use TF32 internally when ``torch.backends.cudnn.allow_tf32`` + is true (matches the kernel-path behaviour). + + Gradients: the fused inference path bypasses autograd, so when a forward is + called with a query that requires grad (e.g. optimising an image against the + reference distribution) it transparently delegates to a kernel-mode model + with exact FP32 ``sim_max``. ``loss.backward()`` then populates the query's + ``.grad``; the backbone weights and references stay frozen. + """ + + def __init__( + self, + reference: torch.Tensor, + resize: Optional[Tuple[int, int]] = None, + precision: Precision = "tf32", + ) -> None: + super().__init__() + if not _HAVE_FUSED: + raise RuntimeError( + "PuzzleSimCUDAFused requires the puzzle_sim_cuda_ext CUDA extension " + "with the fused inference module built in. Rebuild the extension." + ) + if not reference.is_cuda: + raise RuntimeError( + "PuzzleSimCUDAFused requires reference to live on a CUDA device." + ) + if precision not in _VALID_PRECISIONS: + raise ValueError(f"precision must be one of {_VALID_PRECISIONS!r}, got {precision!r}") + if precision == "tf32" and not _device_capability_at_least(8): + precision = "fp32" + if precision == "fp16" and not _device_capability_at_least(7): + precision = "fp32" + + self.resize = resize + self.precision: Precision = precision + self.device = reference.device + + backbone = SqueezeNet(pretrained=True, requires_grad=False).to(reference.device).eval() + for p in backbone.parameters(): + p.requires_grad = False + weights = _extract_squeeze_weights(backbone) + self._backbone = backbone # kept alive so weight tensors stay valid + + self.scaling_layer = ScalingLayer().to(reference.device) + + self._fused = _ext.FusedSqueezeNet(weights, precision) + self.reference = reference + self._ref_layers: Optional[Tuple[int, ...]] = None + # Lazily built when a forward needs gradients (see _grad_forward). + self._grad_model: Optional[nn.Module] = None + + # ------------------------------------------------------------------ + # Input preprocessing kept in Python; the heavy lifting lives in C++. + # ------------------------------------------------------------------ + def _scaled_input(self, img: torch.Tensor, normalize: bool) -> torch.Tensor: + if img.dim() == 3: + img = img.unsqueeze(0) + if normalize: + img = 2 * img - 1 + img = self.scaling_layer(img) + if self.resize is not None: + img = _resize_tensor(img, size=self.resize, align_corners=True) + return img.contiguous() + + def _ensure_reference_packed(self, layers: Tuple[int, ...]) -> None: + if self._ref_layers is not None and tuple(self._ref_layers) == tuple(layers): + return + with torch.no_grad(): + scaled_refs = self._scaled_input(self.reference, normalize=True) + self._fused.set_reference(scaled_refs, list(layers)) + self._ref_layers = tuple(layers) + + # Public for parity with PuzzleSimCUDA tests + benchmarks. + def compute_features( + self, + img: torch.Tensor, + normalize: bool = False, + layers: Tuple[int, ...] = (0, 1, 2, 3, 4, 5, 6), + ) -> Dict[int, torch.Tensor]: + img = img.to(self.device) + with torch.no_grad(): + scaled = self._scaled_input(img, normalize) + return self._fused.compute_features(scaled, list(layers)) + + def _grad_forward( + self, + img: torch.Tensor, + layers: Tuple[int, ...], + normalize: bool, + reduction: Literal["mean", "sum"], + weights: Optional[Tuple[float, ...]], + ) -> torch.Tensor: + """Differentiable forward for query-image gradients. + + The fused C++ path has no backward (it bypasses autograd entirely), so + when ``img`` carries grad we route through a kernel-mode model built + from the same pretrained weights and reference. That path computes the + backbone with torchvision (frozen weights, grad w.r.t. the input) and an + exact FP32 ``sim_max``, so ``loss.backward()`` populates ``img.grad``. + """ + if self._grad_model is None: + from .puzzle_sim_cuda import PuzzleSimCUDA + + self._grad_model = PuzzleSimCUDA( + self.reference, + net_type="squeeze", + resize=self.resize, + precision="fp32", + ) + return self._grad_model( + img, + layers=layers, + normalize=normalize, + reduction=reduction, + weights=weights, + ) + + def forward( + self, + img: torch.Tensor, + layers: Tuple[int, ...] = (2, 3, 4), + normalize: bool = True, + reduction: Literal["mean", "sum"] = "sum", + weights: Optional[Tuple[float, ...]] = (0.67, 0.2, 0.13), + ) -> torch.Tensor: + if weights is not None and len(weights) != len(layers): + raise ValueError("Number of weights must match number of layers.") + + if _grad_active(img): + return self._grad_forward(img, layers, normalize, reduction, weights) + + self._ensure_reference_packed(tuple(layers)) + + if img.dim() == 3: + img = img.unsqueeze(0) + out_hw = (int(img.shape[-2]), int(img.shape[-1])) + + with torch.no_grad(): + scaled = self._scaled_input(img.to(self.device), normalize) + w_list = [float(w) for w in weights] if weights is not None else [] + return self._fused.forward( + scaled, + list(layers), + w_list, + reduction, + list(out_hw), + ) + + +__all__ = ["PuzzleSimCUDAFused", "Precision"] diff --git a/puzzle_sim_cuda/requirements.txt b/puzzle_sim_cuda/requirements.txt new file mode 100644 index 0000000..ad0bbb4 --- /dev/null +++ b/puzzle_sim_cuda/requirements.txt @@ -0,0 +1,17 @@ +# PuzzleSim CUDA Requirements + +# Core dependencies +torch>=1.13.0 +torchvision>=0.14.0 +numpy>=1.21.0 + +# Build dependencies +pybind11>=2.10.0 + +# Optional dependencies for development and testing +matplotlib>=3.5.0 # For plotting and visualization +pillow>=9.0.0 # For image loading in tests + +# Original PuzzleSim dependencies +torchmetrics>=1.0.0 + diff --git a/puzzle_sim_cuda/setup.py b/puzzle_sim_cuda/setup.py new file mode 100644 index 0000000..5bfa63f --- /dev/null +++ b/puzzle_sim_cuda/setup.py @@ -0,0 +1,62 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Build script for the PuzzleSim CUDA extension. + +Run ``pip install -e .`` from this directory, or ``python setup.py build_ext --inplace`` +to drop the extension next to the Python sources. +""" + +import os + +import torch +from setuptools import setup +from torch.utils.cpp_extension import BuildExtension, CUDAExtension + + +def _detected_arch() -> list[str]: + """Return a TORCH_CUDA_ARCH_LIST-compatible list.""" + env = os.environ.get("TORCH_CUDA_ARCH_LIST") + if env: + return [a.strip() for a in env.split(";") if a.strip()] + if torch.cuda.is_available(): + major, minor = torch.cuda.get_device_capability() + return [f"{major}.{minor}"] + # Reasonable defaults for the GPUs we expect to see. + return ["7.0", "7.5", "8.0", "8.6", "8.9", "9.0"] + + +arch_list = _detected_arch() +os.environ.setdefault("TORCH_CUDA_ARCH_LIST", ";".join(arch_list)) + +ext_modules = [ + CUDAExtension( + name="puzzle_sim_cuda_ext", + sources=[ + "src/puzzle_sim_cuda.cpp", + "src/fused_inference.cpp", + "src/kernels.cu", + ], + extra_compile_args={ + "cxx": ["/O2"] if os.name == "nt" else ["-O3"], + "nvcc": [ + "-O3", + "--use_fast_math", + "--expt-relaxed-constexpr", + # Newer host compilers (e.g. MSVC 2026) are not yet on the + # CUDA toolkit's supported list but still produce correct code. + "-allow-unsupported-compiler", + ], + }, + ), +] + +setup( + name="puzzle_sim_cuda", + version="0.2.0", + description="CUDA-accelerated PuzzleSim implementation", + packages=["puzzle_sim_cuda"], + package_dir={"puzzle_sim_cuda": "."}, + ext_modules=ext_modules, + cmdclass={"build_ext": BuildExtension}, + zip_safe=False, + python_requires=">=3.8", +) diff --git a/puzzle_sim_cuda/src/fused_inference.cpp b/puzzle_sim_cuda/src/fused_inference.cpp new file mode 100644 index 0000000..2c19ba3 --- /dev/null +++ b/puzzle_sim_cuda/src/fused_inference.cpp @@ -0,0 +1,529 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// Fully fused PuzzleSim forward over the SqueezeNet1.1 backbone. Owns: +// * pre-extracted, contiguous weight + bias tensors, +// * pre-packed reference features (one per requested layer), +// * the entire backbone -> normalize -> sim_max -> upsample -> weighted-sum +// pipeline, executed back-to-back in a single C++ call so there is no +// Python dispatch between the 8 Fire modules / 3 taps. +// +// Convolutions go through at::cudnn_convolution_relu, which is PyTorch's +// thin wrapper around cudnnConvolutionBiasActivationForward (single fused +// conv + bias + ReLU cuDNN op). Max-pool uses at::max_pool2d. The custom +// kernels (normalize / sim_max / bilinear_upsample) are reused from +// kernels.cu via the existing C-linkage launchers. + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +// Forward declarations of the C-linkage kernel launchers from kernels.cu +extern "C" { +void launch_normalize_features( + const float* input, float* output, + int batch_size, int channels, int height, int width, + float eps, cudaStream_t stream); + +void launch_sim_max_tf32( + const float* Q, const float* R, + float* out, float* partial_max, + int C_padded, int qHW_padded, int K_padded, + int qHW, int K, cudaStream_t stream); + +void launch_sim_max_fp16( + const __half* Q, const __half* R, + float* out, float* partial_max, + int C_padded, int qHW_padded, int K_padded, + int qHW, int K, cudaStream_t stream); + +int sim_max_tile_m(); +int sim_max_tile_n(); + +void launch_bilinear_upsample( + const float* input, float* output, + int in_h, int in_w, int out_h, int out_w, + bool align_corners, cudaStream_t stream); +} + +namespace fused { + +namespace { + +// SqueezeNet1.1 weight layout. The constructor receives a flat std::vector +// of tensors; these indices document where each weight lives. +// +// [0] conv0.weight (64, 3, 3, 3) +// [1] conv0.bias (64,) +// [2 + 6*k + 0] fire[k].squeeze.weight +// [2 + 6*k + 1] fire[k].squeeze.bias +// [2 + 6*k + 2] fire[k].expand1x1.weight +// [2 + 6*k + 3] fire[k].expand1x1.bias +// [2 + 6*k + 4] fire[k].expand3x3.weight +// [2 + 6*k + 5] fire[k].expand3x3.bias +// for k = 0..7. +constexpr int N_FIRES = 8; +constexpr int N_TENSORS = 2 + 6 * N_FIRES; // 50 + +inline cudaStream_t current_stream() { + return at::cuda::getCurrentCUDAStream(); +} + +inline int round_up(int x, int mult) { + return ((x + mult - 1) / mult) * mult; +} + +inline at::Tensor maybe_pad_2d(const at::Tensor& t, int new_rows, int new_cols) { + if (t.size(0) == new_rows && t.size(1) == new_cols) { + return t; + } + auto padded = torch::zeros({new_rows, new_cols}, t.options()); + padded.narrow(0, 0, t.size(0)).narrow(1, 0, t.size(1)).copy_(t); + return padded; +} + +inline at::Tensor conv_relu( + const at::Tensor& x, + const at::Tensor& w, + const at::Tensor& b, + std::vector stride, + std::vector padding) +{ + // cuDNN-backed conv + bias + ReLU in one op. + return at::cudnn_convolution_relu( + x, w, b, + at::IntArrayRef(stride), + at::IntArrayRef(padding), + at::IntArrayRef({1, 1}), // dilation + /*groups=*/1); +} + +// Fire module: squeeze (1x1) -> expand_1x1 (1x1) concat expand_3x3 (3x3). +inline at::Tensor fire_forward( + const at::Tensor& x, + const at::Tensor& sq_w, const at::Tensor& sq_b, + const at::Tensor& e1_w, const at::Tensor& e1_b, + const at::Tensor& e3_w, const at::Tensor& e3_b) +{ + auto sq = conv_relu(x, sq_w, sq_b, {1, 1}, {0, 0}); + auto e1 = conv_relu(sq, e1_w, e1_b, {1, 1}, {0, 0}); + auto e3 = conv_relu(sq, e3_w, e3_b, {1, 1}, {1, 1}); + return at::cat({e1, e3}, /*dim=*/1); +} + +inline at::Tensor maxpool_3x3_s2_ceil(const at::Tensor& x) { + return at::max_pool2d( + x, + /*kernel_size=*/at::IntArrayRef({3, 3}), + /*stride=*/at::IntArrayRef({2, 2}), + /*padding=*/at::IntArrayRef({0, 0}), + /*dilation=*/at::IntArrayRef({1, 1}), + /*ceil_mode=*/true); +} + +// Channel-wise L2 normalize via the existing CUDA kernel. +inline at::Tensor normalize_features(const at::Tensor& x, double eps = 1e-8) { + TORCH_CHECK(x.is_cuda(), "normalize_features requires a CUDA tensor"); + TORCH_CHECK(x.dim() == 4, "normalize_features expects 4D (N, C, H, W)"); + auto x_c = x.contiguous(); + auto out = torch::empty_like(x_c); + launch_normalize_features( + x_c.data_ptr(), + out.data_ptr(), + static_cast(x_c.size(0)), + static_cast(x_c.size(1)), + static_cast(x_c.size(2)), + static_cast(x_c.size(3)), + static_cast(eps), + current_stream()); + return out; +} + +// Pack (N, C, H, W) -> (C, N*H*W). Same convention as the existing +// pack_reference kernel; kept as a thin wrapper here so we can call it +// from C++ on the L2-normalized backbone outputs. +inline at::Tensor pack_features(const at::Tensor& feats) { + TORCH_CHECK(feats.dim() == 4, "pack_features expects 4D (N, C, H, W)"); + const auto N = feats.size(0); + const auto C = feats.size(1); + const auto H = feats.size(2); + const auto W = feats.size(3); + return feats.transpose(0, 1).contiguous().reshape({C, N * H * W}); +} + +// Tensor-core fused GEMM + per-row max. Mirrors the bindings in +// puzzle_sim_cuda.cpp; we duplicate here to keep this translation unit +// self-contained for the fused class. +inline at::Tensor sim_max_dispatch( + const at::Tensor& query_packed, // (C, qHW) + const at::Tensor& refs_packed, // (C, K) + int qH, int qW, + const std::string& precision) +{ + const int TC_TILE_M = sim_max_tile_m(); + const int TC_TILE_N = sim_max_tile_n(); + + const int C = static_cast(query_packed.size(0)); + const int qHW = static_cast(query_packed.size(1)); + const int K = static_cast(refs_packed.size(1)); + TORCH_CHECK(qH * qW == qHW, "query_hw does not match query_packed.shape[1]"); + + if (precision == "fp32") { + // Chunked matmul + max fallback. Mirrors the Python fallback exactly + // but keeps everything on stream without round-tripping to Python. + constexpr int64_t SCORE_CHUNK_BYTES = 256LL * 1024 * 1024; + const int64_t bytes_per = query_packed.element_size(); + const int64_t max_chunk = + std::max(1, SCORE_CHUNK_BYTES / std::max(1, qHW * bytes_per)); + const int64_t chunk = std::min(K, max_chunk); + + auto q_t = query_packed.transpose(0, 1); // (qHW, C) + if (chunk >= K) { + auto scores = at::matmul(q_t, refs_packed); // (qHW, K) + auto sim = std::get<0>(scores.max(/*dim=*/1)); + return sim.reshape({qH, qW}); + } + auto sim_map = torch::full({qHW}, + -std::numeric_limits::infinity(), + query_packed.options()); + for (int64_t k0 = 0; k0 < K; k0 += chunk) { + int64_t k1 = std::min(k0 + chunk, K); + auto partial = at::matmul(q_t, refs_packed.narrow(/*dim=*/1, k0, k1 - k0)); + auto partial_max = std::get<0>(partial.max(/*dim=*/1)); + sim_map = at::maximum(sim_map, partial_max); + } + return sim_map.reshape({qH, qW}); + } + + // Tensor-core path + const bool fp16 = (precision == "fp16"); + const int WMMA_K = fp16 ? 16 : 8; + const int C_padded = round_up(C, WMMA_K); + const int qHW_padded = round_up(qHW, TC_TILE_M); + const int K_padded = round_up(K, TC_TILE_N); + const int n_chunks = K_padded / TC_TILE_N; + + auto Q = maybe_pad_2d(query_packed, C_padded, qHW_padded); + auto R = maybe_pad_2d(refs_packed, C_padded, K_padded); + + auto float_opts = query_packed.options().dtype(at::kFloat); + auto out = torch::empty({qH, qW}, float_opts); + auto partial = torch::empty({qHW_padded, n_chunks}, float_opts); + + if (fp16) { + launch_sim_max_fp16( + reinterpret_cast(Q.data_ptr()), + reinterpret_cast(R.data_ptr()), + out.data_ptr(), + partial.data_ptr(), + C_padded, qHW_padded, K_padded, qHW, K, + current_stream()); + } else { + launch_sim_max_tf32( + Q.data_ptr(), + R.data_ptr(), + out.data_ptr(), + partial.data_ptr(), + C_padded, qHW_padded, K_padded, qHW, K, + current_stream()); + } + return out; +} + +inline at::Tensor bilinear_upsample( + const at::Tensor& x, int64_t out_h, int64_t out_w, bool align_corners) +{ + TORCH_CHECK(x.is_cuda() && x.dim() == 2 && x.scalar_type() == at::kFloat, + "bilinear_upsample expects a 2D float CUDA tensor"); + auto x_c = x.contiguous(); + auto out = torch::empty({out_h, out_w}, x_c.options()); + launch_bilinear_upsample( + x_c.data_ptr(), + out.data_ptr(), + static_cast(x_c.size(0)), static_cast(x_c.size(1)), + static_cast(out_h), static_cast(out_w), + align_corners, + current_stream()); + return out; +} + +} // namespace + +// ===================================================================== +// FusedSqueezeNet - holds packed weights + cached reference features, +// runs the full PuzzleSim pipeline in a single C++ call. +// ===================================================================== +class FusedSqueezeNet { +public: + FusedSqueezeNet(std::vector weights, + const std::string& precision) + : w_(std::move(weights)), precision_(precision) + { + TORCH_CHECK( + static_cast(w_.size()) == N_TENSORS, + "FusedSqueezeNet expects ", N_TENSORS, " weight tensors, got ", w_.size()); + for (size_t i = 0; i < w_.size(); ++i) { + TORCH_CHECK(w_[i].is_cuda(), "weight ", i, " must be CUDA"); + TORCH_CHECK(w_[i].scalar_type() == at::kFloat, + "weight ", i, " must be float32; got ", w_[i].scalar_type()); + if (!w_[i].is_contiguous()) { + w_[i] = w_[i].contiguous(); + } + } + validate_precision(precision_); + } + + // Run the SqueezeNet backbone on `scaled_img` and return the + // L2-normalized feature maps at the requested slice indices. + // + // `scaled_img` is expected to be (1, 3, H, W) and to have already + // been through any scaling layer + optional resize (kept in Python). + std::map compute_features( + at::Tensor scaled_img, + std::vector layers) + { + TORCH_CHECK(scaled_img.is_cuda(), "scaled_img must be CUDA"); + if (scaled_img.dim() == 3) scaled_img = scaled_img.unsqueeze(0); + TORCH_CHECK(scaled_img.dim() == 4 && scaled_img.size(1) == 3, + "scaled_img must be (N, 3, H, W)"); + + std::map tap_raw = forward_backbone(scaled_img, layers); + + std::map out; + for (auto& kv : tap_raw) { + out[kv.first] = normalize_features(kv.second); + } + return out; + } + + // Pack & cache reference features. Stores `(C, K)` packed tensors + // (FP32 by default; FP16 mirror is built lazily for the fp16 precision + // path the first time it is needed for a layer). + // + // `scaled_refs` is the reference distribution after scaling + resize, + // shape `(N, 3, H, W)`. + void set_reference(at::Tensor scaled_refs, + std::vector layers) + { + auto feats = compute_features(std::move(scaled_refs), layers); + refs_packed_.clear(); + refs_packed_fp16_.clear(); + ref_hw_.clear(); + for (auto& kv : feats) { + const auto& f = kv.second; + refs_packed_[kv.first] = pack_features(f); + ref_hw_[kv.first] = std::make_pair( + f.size(2), f.size(3)); + } + } + + bool has_reference() const { + return !refs_packed_.empty(); + } + + // The whole pipeline in one call. Returns a (out_h, out_w) similarity map. + at::Tensor forward(at::Tensor scaled_img, + std::vector layers, + std::vector weights, + const std::string& reduction, + std::vector out_hw) + { + TORCH_CHECK(!refs_packed_.empty(), + "set_reference must be called before forward"); + TORCH_CHECK(out_hw.size() == 2, "out_hw must be of length 2"); + TORCH_CHECK(weights.empty() || weights.size() == layers.size(), + "weights size must match layers size or be empty"); + + auto feats = compute_features(std::move(scaled_img), layers); + + at::Tensor sum_map; + bool first = true; + for (size_t i = 0; i < layers.size(); ++i) { + int64_t layer = layers[i]; + auto fit = feats.find(layer); + auto rit = refs_packed_.find(layer); + auto hit = ref_hw_.find(layer); + TORCH_CHECK(fit != feats.end(), "missing query feats for layer ", layer); + TORCH_CHECK(rit != refs_packed_.end(), + "missing packed refs for layer ", layer, + " - call set_reference with this layer first"); + (void)hit; // ref_hw is kept for callers that want it; not needed here + + // Re-pack: (1, C, qH, qW) -> (C, qHW) + const auto& q = fit->second; + TORCH_CHECK(q.dim() == 4, "query feats must be 4D"); + const int qH = static_cast(q.size(2)); + const int qW = static_cast(q.size(3)); + const int C = static_cast(q.size(1)); + auto q_packed = q.reshape({C, qH * qW}).contiguous(); + + // Picks the right refs tensor based on precision. + at::Tensor r_packed = refs_for_layer(layer); + if (precision_ == "fp16") { + q_packed = q_packed.to(at::kHalf).contiguous(); + } + + auto sim_map = sim_max_dispatch(q_packed, r_packed, qH, qW, precision_); + auto up_map = bilinear_upsample(sim_map, out_hw[0], out_hw[1], /*align_corners=*/true); + if (!weights.empty()) { + up_map = up_map * weights[i]; + } + if (first) { + sum_map = up_map; + first = false; + } else { + sum_map = sum_map + up_map; + } + } + + if (reduction == "mean" && !layers.empty()) { + sum_map = sum_map / static_cast(layers.size()); + } + return sum_map; + } + + std::string precision() const { return precision_; } + + void set_precision(const std::string& p) { + validate_precision(p); + precision_ = p; + // Drop the FP16 cache so it gets rebuilt with the right dtype. + refs_packed_fp16_.clear(); + } + +private: + static void validate_precision(const std::string& p) { + TORCH_CHECK(p == "fp32" || p == "tf32" || p == "fp16", + "precision must be one of {fp32, tf32, fp16}; got ", p); + } + + // Run the backbone and harvest the requested tap outputs. + std::map forward_backbone( + at::Tensor x, + const std::vector& layers) + { + // Layer index -> tap point in the topology: + // layer 0: conv0+relu + // layer 1: slice1 last fire (idx 1) + // layer 2: slice2 last fire (idx 3) + // layer 3: slice3 last fire (idx 4) + // layer 4: slice4 (idx 5) + // layer 5: slice5 (idx 6) + // layer 6: slice6 (idx 7) + std::map want; + int64_t max_layer = -1; + for (auto l : layers) { + want[l] = true; + if (l > max_layer) max_layer = l; + } + + std::map out; + + // Slice 0: conv0 (stride 2, padding 0) + ReLU. + x = conv_relu(x, w_[0], w_[1], {2, 2}, {0, 0}); + if (want.count(0)) out[0] = x; + if (max_layer == 0) return out; + + // Slice 1: maxpool, fire 0 (in=64), fire 1 (in=128, out=128). + x = maxpool_3x3_s2_ceil(x); + x = fire_at(x, 0); + x = fire_at(x, 1); + if (want.count(1)) out[1] = x; + if (max_layer == 1) return out; + + // Slice 2: maxpool, fire 2 (in=128, out=256), fire 3 (in=256, out=256). + x = maxpool_3x3_s2_ceil(x); + x = fire_at(x, 2); + x = fire_at(x, 3); + if (want.count(2)) out[2] = x; + if (max_layer == 2) return out; + + // Slice 3: maxpool, fire 4 (in=256, out=384). + x = maxpool_3x3_s2_ceil(x); + x = fire_at(x, 4); + if (want.count(3)) out[3] = x; + if (max_layer == 3) return out; + + // Slice 4: fire 5 (in=384, out=384). + x = fire_at(x, 5); + if (want.count(4)) out[4] = x; + if (max_layer == 4) return out; + + // Slice 5: fire 6 (in=384, out=512). + x = fire_at(x, 6); + if (want.count(5)) out[5] = x; + if (max_layer == 5) return out; + + // Slice 6: fire 7 (in=512, out=512). + x = fire_at(x, 7); + if (want.count(6)) out[6] = x; + return out; + } + + inline at::Tensor fire_at(const at::Tensor& x, int k) { + const int base = 2 + 6 * k; + return fire_forward( + x, + w_[base + 0], w_[base + 1], // squeeze + w_[base + 2], w_[base + 3], // expand 1x1 + w_[base + 4], w_[base + 5]); // expand 3x3 + } + + const at::Tensor& refs_for_layer(int64_t layer) { + auto& fp32 = refs_packed_.at(layer); + if (precision_ != "fp16") return fp32; + auto it = refs_packed_fp16_.find(layer); + if (it == refs_packed_fp16_.end()) { + it = refs_packed_fp16_.emplace( + layer, fp32.to(at::kHalf).contiguous()).first; + } + return it->second; + } + + std::vector w_; + std::map refs_packed_; + std::map refs_packed_fp16_; + std::map> ref_hw_; + std::string precision_; +}; + +} // namespace fused + +// ----------------------------------------------------------------------------- +// pybind11 registration. Symbol-visible from the main puzzle_sim_cuda.cpp via +// a register_fused_inference(module&) helper invoked inside PYBIND11_MODULE. +// ----------------------------------------------------------------------------- +void register_fused_inference(pybind11::module& m) { + namespace py = pybind11; + py::class_(m, "FusedSqueezeNet") + .def(py::init, std::string>(), + py::arg("weights"), + py::arg("precision") = "tf32") + .def("compute_features", &fused::FusedSqueezeNet::compute_features, + py::arg("scaled_img"), + py::arg("layers"), + "Run scaling-free backbone + L2-normalize. Returns dict layer -> tensor.") + .def("set_reference", &fused::FusedSqueezeNet::set_reference, + py::arg("scaled_refs"), + py::arg("layers"), + "Compute and cache packed reference features.") + .def("has_reference", &fused::FusedSqueezeNet::has_reference, + "True once set_reference has been called.") + .def("forward", &fused::FusedSqueezeNet::forward, + py::arg("scaled_img"), + py::arg("layers"), + py::arg("weights"), + py::arg("reduction") = "sum", + py::arg("out_hw"), + "Full PuzzleSim forward in one C++ call. Returns (H, W) sim map.") + .def_property("precision", + &fused::FusedSqueezeNet::precision, + &fused::FusedSqueezeNet::set_precision); +} diff --git a/puzzle_sim_cuda/src/kernels.cu b/puzzle_sim_cuda/src/kernels.cu new file mode 100644 index 0000000..4b0881b --- /dev/null +++ b/puzzle_sim_cuda/src/kernels.cu @@ -0,0 +1,404 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// CUDA kernels for PuzzleSim. +// +// Forward path: +// * normalize_features_kernel - channel-wise L2 normalization with rsqrt. +// * sim_max_tc_kernel - tensor-core GEMM + per-tile max reduction. +// Split-K: grid is (qHW/TILE_M, K/TILE_N), each block emits one partial +// max per query row in its N-chunk. A second kernel reduces along K. +// T=float,WMMA_K=8 is the TF32 path (sm_80+). +// T=__half,WMMA_K=16 is the FP16 path with FP32 accumulator (sm_70+). +// * sim_max_reduce_kernel - reduces (qHW, n_chunks) partial maxes to (qHW,). +// * bilinear_upsample_kernel - 2D bilinear upsample of a similarity map. + +#include +#include +#include +#include + +namespace wmma = nvcuda::wmma; + +// ----------------------------------------------------------------------------- +// Feature normalization +// ----------------------------------------------------------------------------- +// +// Computes out[n, c, y, x] = in[n, c, y, x] / sqrt(eps + sum_c in[n, c, y, x]^2) +__global__ void normalize_features_kernel( + const float* __restrict__ input, + float* __restrict__ output, + int batch_size, + int channels, + int spatial_size, + float eps) +{ + int total_threads = batch_size * spatial_size; + int tid = blockIdx.x * blockDim.x + threadIdx.x; + int stride = blockDim.x * gridDim.x; + + for (int idx = tid; idx < total_threads; idx += stride) { + int batch = idx / spatial_size; + int spatial = idx - batch * spatial_size; + + const float* in_ptr = input + batch * channels * spatial_size + spatial; + float* out_ptr = output + batch * channels * spatial_size + spatial; + + float norm_sq = 0.0f; + #pragma unroll 8 + for (int c = 0; c < channels; ++c) { + float v = in_ptr[c * spatial_size]; + norm_sq += v * v; + } + + float inv_norm = rsqrtf(norm_sq + eps); + + #pragma unroll 8 + for (int c = 0; c < channels; ++c) { + out_ptr[c * spatial_size] = in_ptr[c * spatial_size] * inv_norm; + } + } +} + +extern "C" void launch_normalize_features( + const float* input, + float* output, + int batch_size, + int channels, + int height, + int width, + float eps, + cudaStream_t stream) +{ + const int spatial = height * width; + const int total = batch_size * spatial; + const int block = 256; + const int grid = min((total + block - 1) / block, 65535); + normalize_features_kernel<<>>( + input, output, batch_size, channels, spatial, eps); +} + +// ----------------------------------------------------------------------------- +// Tensor-core sim_max (split-K + reduce) +// ----------------------------------------------------------------------------- +// +// Computes: out[q] = max_k sum_c Q[c, q] * R[c, k] +// +// Layout requirements: +// Q : (C_padded, qHW_padded), row-major in memory. +// R : (C_padded, K_padded), row-major in memory. +// "_padded" means rounded up to TILE_M, TILE_N, or WMMA_K as required; the +// padded region is filled with zeros by the host so dot-products are +// unaffected. The reduction additionally clips the max to ``K`` (so padded +// K columns cannot win the max). +// +// Strategy: +// * Grid = (qHW_padded/TILE_M, K_padded/TILE_N). 4090 has 128 SMs; for the +// garden-l2 scale that is ~70k blocks, plenty of parallelism. +// * Each block computes ONE (TILE_M, TILE_N) score tile and reduces it to +// (TILE_M,) partial max along its N-chunk. +// * The host follows up with sim_max_reduce_kernel to collapse the per-block +// partial maxes along the K dimension. +// * Per block: 4 warps each own a 16-row band; per c_chunk both A and B are +// staged into shared memory cooperatively so the four warps share the +// loads from global. After accumulating all of C, fragments are stored to +// a 64x68 (padding for bank-conflict-free reduce) shared-memory tile. + +constexpr int TILE_M = 64; +constexpr int TILE_N = 128; +constexpr int WARPS_PER_BLOCK = 4; // TILE_M / 16 +constexpr int N_FRAGS_PER_WARP = 8; // TILE_N / 16 +constexpr int THREADS_PER_BLOCK = WARPS_PER_BLOCK * 32; // 128 + +// Per-precision fragment types and prepare() (rounding) hook. +template +struct WmmaTraits; + +template <> +struct WmmaTraits { + using a_frag = wmma::fragment; + using b_frag = wmma::fragment; + using c_frag = wmma::fragment; + using storage = float; + + template + static __device__ __forceinline__ void prepare(F& f) { + #pragma unroll + for (int i = 0; i < f.num_elements; i++) { + f.x[i] = wmma::__float_to_tf32(f.x[i]); + } + } +}; + +template <> +struct WmmaTraits<__half, 16> { + using a_frag = wmma::fragment; + using b_frag = wmma::fragment; + using c_frag = wmma::fragment; + using storage = __half; + + template + static __device__ __forceinline__ void prepare(F&) { /* fp16 needs no manual rounding */ } +}; + +template +__global__ void sim_max_tc_kernel( + const T* __restrict__ Q, // (C_padded, qHW_padded) + const T* __restrict__ R, // (C_padded, K_padded) + float* __restrict__ partial_max, // (qHW_padded, n_chunks) + int C_padded, + int qHW_padded, + int K_padded, + int K, + int n_chunks) +{ + using Traits = WmmaTraits; + using a_frag_t = typename Traits::a_frag; + using b_frag_t = typename Traits::b_frag; + using c_frag_t = typename Traits::c_frag; + + const int tid = threadIdx.x; + const int warp_id = tid >> 5; // 0..3 + const int block_m = blockIdx.x * TILE_M; + const int n_chunk_idx = blockIdx.y; + const int n_start = n_chunk_idx * TILE_N; + if (block_m >= qHW_padded) return; + const int warp_m_offset = warp_id * 16; + + // Shared memory staging for A (Q tile) and B (R tile). + __shared__ T A_shared[TILE_M * WMMA_K]; + __shared__ T B_shared[WMMA_K * TILE_N]; + + // +4 padding eliminates the 32-way bank conflict the row-wise reduce would + // otherwise hit (with LD == TILE_N, every row would start in bank 0). Must + // also be a multiple of 4 (wmma::store_matrix_sync constraint). + // Each warp owns its own 16 x LD slot in shmem to halve the total + // footprint vs a single TILE_M x LD region - the per-warp slots aren't + // shared across warps, so we can fit more concurrent blocks per SM. + constexpr int LD = TILE_N + 4; + __shared__ float score_tiles[WARPS_PER_BLOCK * 16 * LD]; + + c_frag_t acc[N_FRAGS_PER_WARP]; + #pragma unroll + for (int i = 0; i < N_FRAGS_PER_WARP; i++) { + wmma::fill_fragment(acc[i], 0.0f); + } + + for (int c_chunk = 0; c_chunk < C_padded; c_chunk += WMMA_K) { + // Cooperative load of A_shared (TILE_M x WMMA_K, row-major) from + // Q (C_padded x qHW_padded, row-major). Walks one C-slice per + // iteration so consecutive threads load consecutive q values for + // the same channel - coalesced 128-byte transactions per warp. + #pragma unroll + for (int i = tid; i < TILE_M * WMMA_K; i += THREADS_PER_BLOCK) { + int c_local = i / TILE_M; + int q_local = i - c_local * TILE_M; + A_shared[q_local * WMMA_K + c_local] = + Q[(c_chunk + c_local) * qHW_padded + block_m + q_local]; + } + + // Cooperative load of B_shared (WMMA_K x TILE_N, row-major). + #pragma unroll + for (int i = tid; i < WMMA_K * TILE_N; i += THREADS_PER_BLOCK) { + int c_local = i / TILE_N; + int n_local = i - c_local * TILE_N; + B_shared[i] = R[(c_chunk + c_local) * K_padded + n_start + n_local]; + } + __syncthreads(); + + a_frag_t a_frag; + wmma::load_matrix_sync( + a_frag, + &A_shared[warp_m_offset * WMMA_K], + WMMA_K); + Traits::prepare(a_frag); + + #pragma unroll + for (int n_frag = 0; n_frag < N_FRAGS_PER_WARP; n_frag++) { + b_frag_t b_frag; + wmma::load_matrix_sync( + b_frag, + &B_shared[n_frag * 16], + TILE_N); + Traits::prepare(b_frag); + + wmma::mma_sync(acc[n_frag], a_frag, b_frag, acc[n_frag]); + } + + __syncthreads(); // before A_shared/B_shared are overwritten next chunk + } + + // Store this warp's 16xTILE_N band into its per-warp shmem slot. + float* warp_tile = &score_tiles[warp_id * 16 * LD]; + #pragma unroll + for (int n_frag = 0; n_frag < N_FRAGS_PER_WARP; n_frag++) { + wmma::store_matrix_sync( + &warp_tile[n_frag * 16], + acc[n_frag], + LD, + wmma::mem_row_major); + } + // No __syncthreads needed: the reduce below only reads this warp's slot, + // and the per-warp slots do not overlap. + + // Row-wise max over the TILE_N columns of this N-chunk, masked to actual K. + // Each warp reduces its own 16 rows; lane 0..15 of each warp handle a row. + const int lane = tid & 31; + if (lane < 16) { + int cols_remaining = K - n_start; + int n_limit = (cols_remaining >= TILE_N) ? TILE_N + : (cols_remaining > 0 ? cols_remaining : 0); + const float* row = &warp_tile[lane * LD]; + float row_max = -CUDART_INF_F; + #pragma unroll 8 + for (int n = 0; n < n_limit; n++) { + row_max = fmaxf(row_max, row[n]); + } + const int global_q = block_m + warp_m_offset + lane; + partial_max[global_q * n_chunks + n_chunk_idx] = row_max; + } +} + +// Reduce (qHW_padded, n_chunks) partial maxes to (qHW,) final maxes. +// One block per query row, threads cooperate over the n_chunks axis. +__global__ void sim_max_reduce_kernel( + const float* __restrict__ partial_max, // (qHW_padded, n_chunks) + float* __restrict__ out, // (qHW,) + int qHW, + int n_chunks) +{ + const int q = blockIdx.x; + if (q >= qHW) return; + const int tid = threadIdx.x; + const int threads = blockDim.x; + + extern __shared__ float buf[]; + float local_max = -CUDART_INF_F; + const float* row = partial_max + (size_t)q * n_chunks; + for (int i = tid; i < n_chunks; i += threads) { + local_max = fmaxf(local_max, row[i]); + } + buf[tid] = local_max; + __syncthreads(); + + // Tree-style reduction within the block. + for (int s = threads >> 1; s > 0; s >>= 1) { + if (tid < s) { + buf[tid] = fmaxf(buf[tid], buf[tid + s]); + } + __syncthreads(); + } + + if (tid == 0) out[q] = buf[0]; +} + +// Host helper that launches the forward + reduce pair. +template +static void launch_sim_max_tc_impl( + const T* Q, const T* R, float* out, + float* partial_max, + int C_padded, int qHW_padded, int K_padded, int qHW, int K, + cudaStream_t stream) +{ + const int n_chunks = K_padded / TILE_N; + dim3 grid(qHW_padded / TILE_M, n_chunks); + sim_max_tc_kernel<<>>( + Q, R, partial_max, C_padded, qHW_padded, K_padded, K, n_chunks); + + // Reduce. 128 threads per row; shared mem = 128 * 4 = 512 B. + const int reduce_threads = 128; + const int reduce_shmem = reduce_threads * sizeof(float); + sim_max_reduce_kernel<<>>( + partial_max, out, qHW, n_chunks); +} + +extern "C" void launch_sim_max_tf32( + const float* Q, const float* R, float* out, + float* partial_max, + int C_padded, int qHW_padded, int K_padded, int qHW, int K, + cudaStream_t stream) +{ + launch_sim_max_tc_impl( + Q, R, out, partial_max, + C_padded, qHW_padded, K_padded, qHW, K, stream); +} + +extern "C" void launch_sim_max_fp16( + const __half* Q, const __half* R, float* out, + float* partial_max, + int C_padded, int qHW_padded, int K_padded, int qHW, int K, + cudaStream_t stream) +{ + launch_sim_max_tc_impl<__half, 16>( + Q, R, out, partial_max, + C_padded, qHW_padded, K_padded, qHW, K, stream); +} + +// Exposes the kernel-side tile sizes to the host bindings so the padding math +// has a single source of truth (see TC_TILE_M/TC_TILE_N use in the .cpp). +extern "C" int sim_max_tile_m() { return TILE_M; } +extern "C" int sim_max_tile_n() { return TILE_N; } + +// ----------------------------------------------------------------------------- +// Bilinear upsample +// ----------------------------------------------------------------------------- +__global__ void bilinear_upsample_kernel( + const float* __restrict__ input, + float* __restrict__ output, + int in_h, + int in_w, + int out_h, + int out_w, + bool align_corners) +{ + int out_y = blockIdx.y * blockDim.y + threadIdx.y; + int out_x = blockIdx.x * blockDim.x + threadIdx.x; + if (out_y >= out_h || out_x >= out_w) return; + + float scale_y, scale_x; + if (align_corners) { + scale_y = (out_h > 1) ? (float)(in_h - 1) / (out_h - 1) : 0.0f; + scale_x = (out_w > 1) ? (float)(in_w - 1) / (out_w - 1) : 0.0f; + } else { + scale_y = (float)in_h / (float)out_h; + scale_x = (float)in_w / (float)out_w; + } + + float src_y = align_corners ? out_y * scale_y : (out_y + 0.5f) * scale_y - 0.5f; + float src_x = align_corners ? out_x * scale_x : (out_x + 0.5f) * scale_x - 0.5f; + + src_y = fmaxf(0.0f, fminf(src_y, (float)(in_h - 1))); + src_x = fmaxf(0.0f, fminf(src_x, (float)(in_w - 1))); + + int y0 = (int)floorf(src_y); + int x0 = (int)floorf(src_x); + int y1 = min(y0 + 1, in_h - 1); + int x1 = min(x0 + 1, in_w - 1); + + float dy = src_y - y0; + float dx = src_x - x0; + + float v00 = input[y0 * in_w + x0]; + float v01 = input[y0 * in_w + x1]; + float v10 = input[y1 * in_w + x0]; + float v11 = input[y1 * in_w + x1]; + + float v0 = v00 * (1.0f - dx) + v01 * dx; + float v1 = v10 * (1.0f - dx) + v11 * dx; + output[out_y * out_w + out_x] = v0 * (1.0f - dy) + v1 * dy; +} + +extern "C" void launch_bilinear_upsample( + const float* input, + float* output, + int in_h, + int in_w, + int out_h, + int out_w, + bool align_corners, + cudaStream_t stream) +{ + dim3 block(16, 16); + dim3 grid((out_w + block.x - 1) / block.x, (out_h + block.y - 1) / block.y); + bilinear_upsample_kernel<<>>( + input, output, in_h, in_w, out_h, out_w, align_corners); +} diff --git a/puzzle_sim_cuda/src/puzzle_sim_cuda.cpp b/puzzle_sim_cuda/src/puzzle_sim_cuda.cpp new file mode 100644 index 0000000..efda697 --- /dev/null +++ b/puzzle_sim_cuda/src/puzzle_sim_cuda.cpp @@ -0,0 +1,321 @@ +// SPDX-License-Identifier: Apache-2.0 +// +// PyTorch bindings for the PuzzleSim CUDA kernels. + +#include +#include +#include +#include +#include + +#include + +// Forward declarations of the C-linkage kernel launchers from kernels.cu +extern "C" { +void launch_normalize_features( + const float* input, + float* output, + int batch_size, + int channels, + int height, + int width, + float eps, + cudaStream_t stream); + +void launch_sim_max_tf32( + const float* Q, + const float* R, + float* out, + float* partial_max, + int C_padded, + int qHW_padded, + int K_padded, + int qHW, + int K, + cudaStream_t stream); + +void launch_sim_max_fp16( + const __half* Q, + const __half* R, + float* out, + float* partial_max, + int C_padded, + int qHW_padded, + int K_padded, + int qHW, + int K, + cudaStream_t stream); + +int sim_max_tile_m(); +int sim_max_tile_n(); + +void launch_bilinear_upsample( + const float* input, + float* output, + int in_h, + int in_w, + int out_h, + int out_w, + bool align_corners, + cudaStream_t stream); +} + +#define CHECK_CUDA(x) TORCH_CHECK((x).is_cuda(), #x " must be a CUDA tensor") +#define CHECK_FLOAT(x) TORCH_CHECK((x).scalar_type() == at::kFloat, #x " must be float32") +#define CHECK_HALF(x) TORCH_CHECK((x).scalar_type() == at::kHalf, #x " must be float16") +#define CHECK_CONTIGUOUS(x) TORCH_CHECK((x).is_contiguous(), #x " must be contiguous") +#define CHECK_INPUT_F32(x) CHECK_CUDA(x); CHECK_FLOAT(x); CHECK_CONTIGUOUS(x) +#define CHECK_INPUT_F16(x) CHECK_CUDA(x); CHECK_HALF(x); CHECK_CONTIGUOUS(x) + +namespace { + +inline cudaStream_t current_stream() { + return at::cuda::getCurrentCUDAStream(); +} + +inline int round_up(int x, int mult) { + return ((x + mult - 1) / mult) * mult; +} + +inline std::pair device_capability() { + int dev = at::cuda::current_device(); + cudaDeviceProp prop; + cudaGetDeviceProperties(&prop, dev); + return {prop.major, prop.minor}; +} + +// Pads a (rows, cols) tensor to (new_rows, new_cols) with zeros. +// Returns the original tensor unchanged when no padding is needed. +torch::Tensor maybe_pad_2d(const torch::Tensor& t, int new_rows, int new_cols) { + if (t.size(0) == new_rows && t.size(1) == new_cols) { + return t; + } + auto padded = torch::zeros({new_rows, new_cols}, t.options()); + padded.narrow(0, 0, t.size(0)).narrow(1, 0, t.size(1)).copy_(t); + return padded; +} + +} // namespace + +// ----------------------------------------------------------------------------- +// normalize_features +// ----------------------------------------------------------------------------- +// +// Out-of-place L2 normalization across the channel axis. +// Input shape: (N, C, H, W). Output shape matches. +torch::Tensor normalize_features(torch::Tensor input, double eps) { + CHECK_INPUT_F32(input); + TORCH_CHECK(input.dim() == 4, "normalize_features expects 4D (N, C, H, W) input"); + + auto output = torch::empty_like(input); + + const int N = input.size(0); + const int C = input.size(1); + const int H = input.size(2); + const int W = input.size(3); + + launch_normalize_features( + input.data_ptr(), + output.data_ptr(), + N, C, H, W, + static_cast(eps), + current_stream()); + + return output; +} + +// ----------------------------------------------------------------------------- +// pack_reference - one-time layout transform +// ----------------------------------------------------------------------------- +// +// Refs come in as (N, C, rH, rW). The similarity routine wants them as +// (C, N * rH * rW) so the contraction axis matches what torch.matmul expects. +// This is just a transpose+reshape but we expose it here so callers can do it +// once and cache the result. +torch::Tensor pack_reference(torch::Tensor refs) { + CHECK_INPUT_F32(refs); + TORCH_CHECK(refs.dim() == 4, "pack_reference expects 4D (N, C, H, W) input"); + + const int N = refs.size(0); + const int C = refs.size(1); + const int H = refs.size(2); + const int W = refs.size(3); + + return refs.transpose(0, 1).contiguous().reshape({C, N * H * W}); +} + +// ----------------------------------------------------------------------------- +// sim_max_tf32 / sim_max_fp16 - tensor-core fused GEMM + per-row max +// ----------------------------------------------------------------------------- + +torch::Tensor sim_max_tf32( + torch::Tensor query_packed, // (C, qHW) + torch::Tensor refs_packed, // (C, K) + std::vector query_hw) +{ + CHECK_INPUT_F32(query_packed); + CHECK_INPUT_F32(refs_packed); + TORCH_CHECK(query_packed.dim() == 2, "query_packed must be 2D (C, qHW)"); + TORCH_CHECK(refs_packed.dim() == 2, "refs_packed must be 2D (C, K)"); + TORCH_CHECK(query_packed.size(0) == refs_packed.size(0), + "Channel dim mismatch between query and refs"); + TORCH_CHECK(query_hw.size() == 2, "query_hw must be of length 2"); + + auto cap = device_capability(); + TORCH_CHECK(cap.first >= 8, + "sim_max_tf32 requires compute capability >= 8.0 (got ", + cap.first, ".", cap.second, "); use fp16 or fp32 fallback"); + + const int C = query_packed.size(0); + const int qHW = query_packed.size(1); + const int K = refs_packed.size(1); + TORCH_CHECK(query_hw[0] * query_hw[1] == qHW, + "query_hw does not match query_packed.shape[1]"); + + constexpr int WMMA_K = 8; + const int TC_TILE_M = sim_max_tile_m(); + const int TC_TILE_N = sim_max_tile_n(); + const int C_padded = round_up(C, WMMA_K); + const int qHW_padded = round_up(qHW, TC_TILE_M); + const int K_padded = round_up(K, TC_TILE_N); + const int n_chunks = K_padded / TC_TILE_N; + + auto Q = maybe_pad_2d(query_packed, C_padded, qHW_padded); + auto R = maybe_pad_2d(refs_packed, C_padded, K_padded); + + auto out = torch::empty({query_hw[0], query_hw[1]}, query_packed.options()); + // Partial maxes from the split-K forward kernel; one float per + // (q_padded, n_chunk). + auto partial = torch::empty( + {qHW_padded, n_chunks}, query_packed.options()); + + launch_sim_max_tf32( + Q.data_ptr(), + R.data_ptr(), + out.data_ptr(), + partial.data_ptr(), + C_padded, qHW_padded, K_padded, qHW, K, + current_stream()); + + return out; +} + +torch::Tensor sim_max_fp16( + torch::Tensor query_packed, // (C, qHW) half + torch::Tensor refs_packed, // (C, K) half + std::vector query_hw) +{ + CHECK_INPUT_F16(query_packed); + CHECK_INPUT_F16(refs_packed); + TORCH_CHECK(query_packed.dim() == 2, "query_packed must be 2D (C, qHW)"); + TORCH_CHECK(refs_packed.dim() == 2, "refs_packed must be 2D (C, K)"); + TORCH_CHECK(query_packed.size(0) == refs_packed.size(0), + "Channel dim mismatch between query and refs"); + TORCH_CHECK(query_hw.size() == 2, "query_hw must be of length 2"); + + auto cap = device_capability(); + TORCH_CHECK(cap.first >= 7, + "sim_max_fp16 requires compute capability >= 7.0 (got ", + cap.first, ".", cap.second, ")"); + + const int C = query_packed.size(0); + const int qHW = query_packed.size(1); + const int K = refs_packed.size(1); + TORCH_CHECK(query_hw[0] * query_hw[1] == qHW, + "query_hw does not match query_packed.shape[1]"); + + constexpr int WMMA_K = 16; + const int TC_TILE_M = sim_max_tile_m(); + const int TC_TILE_N = sim_max_tile_n(); + const int C_padded = round_up(C, WMMA_K); + const int qHW_padded = round_up(qHW, TC_TILE_M); + const int K_padded = round_up(K, TC_TILE_N); + const int n_chunks = K_padded / TC_TILE_N; + + auto Q = maybe_pad_2d(query_packed, C_padded, qHW_padded); + auto R = maybe_pad_2d(refs_packed, C_padded, K_padded); + + auto float_opts = query_packed.options().dtype(at::kFloat); + auto out = torch::empty({query_hw[0], query_hw[1]}, float_opts); + auto partial = torch::empty({qHW_padded, n_chunks}, float_opts); + + launch_sim_max_fp16( + reinterpret_cast(Q.data_ptr()), + reinterpret_cast(R.data_ptr()), + out.data_ptr(), + partial.data_ptr(), + C_padded, qHW_padded, K_padded, qHW, K, + current_stream()); + + return out; +} + +// ----------------------------------------------------------------------------- +// bilinear_upsample +// ----------------------------------------------------------------------------- +// +// 2D bilinear upsample of a single (H, W) similarity map. +torch::Tensor bilinear_upsample( + torch::Tensor input, + std::vector output_size, + bool align_corners) +{ + CHECK_INPUT_F32(input); + TORCH_CHECK(input.dim() == 2, "bilinear_upsample expects 2D (H, W) input"); + TORCH_CHECK(output_size.size() == 2, "output_size must be of length 2"); + + const int in_h = input.size(0); + const int in_w = input.size(1); + const int out_h = output_size[0]; + const int out_w = output_size[1]; + + auto out = torch::empty({out_h, out_w}, input.options()); + + launch_bilinear_upsample( + input.data_ptr(), + out.data_ptr(), + in_h, in_w, out_h, out_w, + align_corners, + current_stream()); + + return out; +} + +// Registers the FusedSqueezeNet class. Implementation lives in +// fused_inference.cpp; forward-declared here so we don't have to drag that +// translation unit's includes into this header-only PYBIND11_MODULE block. +void register_fused_inference(pybind11::module& m); + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.doc() = "CUDA-accelerated kernels for PuzzleSim"; + + m.def("normalize_features", &normalize_features, + "Channel-wise L2 normalization (CUDA)", + py::arg("input"), + py::arg("eps") = 1e-8); + + m.def("pack_reference", &pack_reference, + "Transpose+flatten reference features into the (C, K) layout used " + "for the similarity contraction", + py::arg("refs")); + + m.def("sim_max_tf32", &sim_max_tf32, + "Tensor-core fused GEMM + per-row max (TF32, sm_80+)", + py::arg("query_packed"), + py::arg("refs_packed"), + py::arg("query_hw")); + + m.def("sim_max_fp16", &sim_max_fp16, + "Tensor-core fused GEMM + per-row max (FP16 inputs, FP32 accumulator, sm_70+)", + py::arg("query_packed"), + py::arg("refs_packed"), + py::arg("query_hw")); + + m.def("bilinear_upsample", &bilinear_upsample, + "Bilinear upsample of a 2D similarity map (CUDA)", + py::arg("input"), + py::arg("output_size"), + py::arg("align_corners") = true); + + register_fused_inference(m); +} diff --git a/puzzle_sim_cuda/tests/__init__.py b/puzzle_sim_cuda/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/puzzle_sim_cuda/tests/conftest.py b/puzzle_sim_cuda/tests/conftest.py new file mode 100644 index 0000000..2b3c1c6 --- /dev/null +++ b/puzzle_sim_cuda/tests/conftest.py @@ -0,0 +1,98 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Shared pytest fixtures for the CUDA test suite.""" + +from __future__ import annotations + +import os +import sys +from pathlib import Path + +import pytest +import torch + +# Make sure we can import both ``puzzle_sim`` (reference) and +# ``puzzle_sim_cuda`` (wrapper) regardless of where pytest is invoked from. +_REPO_ROOT = Path(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))) +_PKG_DIR = Path(os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) +for p in (_REPO_ROOT, _PKG_DIR): + sp = str(p) + if sp not in sys.path: + sys.path.insert(0, sp) + + +def _have_cuda() -> bool: + return torch.cuda.is_available() + + +def _have_ext() -> bool: + try: + import puzzle_sim_cuda_ext # noqa: F401 + except ImportError: + return False + return True + + +def _demo_dataset_dir(name: str) -> Path | None: + """Return the path to a demo-data sample directory, or ``None`` if missing. + + Used by tests that need real images. We skip rather than fail when the + data is unavailable so the suite still passes on machines that don't + have the demo submodule checked out. + """ + base = _REPO_ROOT / "PuzzleSim-demo-data" / "samples" / name + if not base.is_dir(): + return None + if not (base / "prior").is_dir() or not (base / "test").is_dir(): + return None + return base + + +requires_cuda = pytest.mark.skipif(not _have_cuda(), reason="CUDA not available") +requires_ext = pytest.mark.skipif(not _have_ext(), reason="CUDA extension not built") + + +def requires_demo_data(name: str): + """Skip marker for tests that need the named demo dataset.""" + return pytest.mark.skipif( + _demo_dataset_dir(name) is None, + reason=f"demo dataset {name!r} not available", + ) + + +@pytest.fixture(autouse=True) +def _seed_torch(): + """Make every test deterministic.""" + torch.manual_seed(0) + if torch.cuda.is_available(): + torch.cuda.manual_seed_all(0) + + +@pytest.fixture(scope="session") +def device() -> str: + return "cuda" if torch.cuda.is_available() else "cpu" + + +@pytest.fixture(scope="session") +def garden_data() -> tuple[torch.Tensor, torch.Tensor, list[str]] | None: + """Load the garden demo dataset onto the GPU once per session. + + Returns ``(priors, tests, test_names)`` or ``None`` if the data is missing. + """ + base = _demo_dataset_dir("garden") + if base is None: + return None + from PIL import Image + import torchvision.transforms.functional as TF + + def _load_dir(dir_path: Path): + names = sorted(p.name for p in dir_path.iterdir() if p.suffix.lower() == ".png") + imgs = [] + for n in names: + im = Image.open(dir_path / n).convert("RGB") + imgs.append(TF.to_tensor(im).unsqueeze(0)) + return torch.cat(imgs, dim=0), names + + device = "cuda" if torch.cuda.is_available() else "cpu" + priors, _ = _load_dir(base / "prior") + tests, test_names = _load_dir(base / "test") + return priors.to(device), tests.to(device), test_names diff --git a/puzzle_sim_cuda/tests/test_fused.py b/puzzle_sim_cuda/tests/test_fused.py new file mode 100644 index 0000000..152abbf --- /dev/null +++ b/puzzle_sim_cuda/tests/test_fused.py @@ -0,0 +1,271 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Correctness tests for the fully-fused C++ implementation. + +``PuzzleSimCUDAFused`` collapses the SqueezeNet1.1 backbone + L2 normalize + +sim_max + bilinear upsample into a single C++ entrypoint. These tests make +sure that, at every supported precision, it produces (up to mode tolerance) +the same output as the kernel implementation ``PuzzleSimCUDA``. + +We also exercise: + +* the feature-extraction subpath, against the reference torchvision SqueezeNet, +* construction-time precision fallback (tf32/fp16 -> fp32 on unsupported + hardware) - this is identical to the kernel-path behaviour, +* the ``PuzzleSim`` factory's ``implementation='fused'`` selector, +* edge cases: per-layer-set selection, repeated forwards, multi-image batch. +""" + +from __future__ import annotations + +import pytest +import torch + +from .conftest import requires_cuda, requires_ext, requires_demo_data + + +# Tolerances against the kernel implementation. fp32 is looser than +# test_tensor_cores because the fused path uses ``at::cudnn_convolution_relu`` +# (a fused conv+bias+ReLU cuDNN op) while the kernel path uses the standard +# ``at::conv2d`` + ``F.relu``. Both run via cuDNN, but each can pick a +# different convolution algorithm, so the per-layer activations agree only to +# within ~1e-4 even with TF32 disabled. Downstream the metric is then summed +# over three taps; the empirical end-to-end drift is ~2e-4. +_TOLERANCE = {"fp32": 2e-4, "tf32": 1e-3, "fp16": 5e-3} + + +def _device_capability_at_least(major: int, minor: int = 0) -> bool: + if not torch.cuda.is_available(): + return False + cap = torch.cuda.get_device_capability() + return cap >= (major, minor) + + +_SKIP_TF32 = pytest.mark.skipif( + not _device_capability_at_least(8), + reason="TF32 tensor cores require compute capability >= 8.0", +) +_SKIP_FP16 = pytest.mark.skipif( + not _device_capability_at_least(7), + reason="FP16 tensor cores require compute capability >= 7.0", +) + + +def _have_fused() -> bool: + try: + import puzzle_sim_cuda_ext + return hasattr(puzzle_sim_cuda_ext, "FusedSqueezeNet") + except ImportError: # pragma: no cover - exercised via skip + return False + + +requires_fused = pytest.mark.skipif( + not _have_fused(), + reason="FusedSqueezeNet not available in the CUDA extension", +) + + +def _abs_err(a: torch.Tensor, b: torch.Tensor) -> float: + return (a - b).abs().max().item() + + +# --------------------------------------------------------------------------- +# Feature extraction agreement: fused backbone vs torchvision reference +# --------------------------------------------------------------------------- + +@requires_cuda +@requires_ext +@requires_fused +def test_fused_backbone_matches_reference_fp32(): + """When TF32 is disabled, fused features must match torchvision to ~1e-7.""" + from puzzle_sim_cuda import PuzzleSimCUDAFused + + prev = torch.backends.cudnn.allow_tf32 + torch.backends.cudnn.allow_tf32 = False + try: + refs = torch.rand(1, 3, 128, 128, device="cuda") + img = torch.rand(1, 3, 128, 128, device="cuda") + fused = PuzzleSimCUDAFused(refs, precision="fp32") + + # Compare directly against the wrapped torchvision SqueezeNet. + with torch.no_grad(): + scaled = fused._scaled_input(img, normalize=True) + ref_outs = fused._backbone(scaled) + + def _norm(x, eps=1e-8): + return x / (eps + x.pow(2).sum(dim=1, keepdim=True)).sqrt() + + feats = fused.compute_features(img, normalize=True, layers=(0, 1, 2, 3, 4, 5, 6)) + for k in range(7): + expected = _norm(ref_outs[k]) + got = feats[k] + err = _abs_err(expected, got) + assert err <= 1e-5, f"layer {k}: max err {err:.3e}" + finally: + torch.backends.cudnn.allow_tf32 = prev + + +# --------------------------------------------------------------------------- +# End-to-end agreement: fused vs kernel implementation +# --------------------------------------------------------------------------- + +@requires_cuda +@requires_ext +@requires_fused +@pytest.mark.parametrize("precision", [ + "fp32", + pytest.param("tf32", marks=_SKIP_TF32), + pytest.param("fp16", marks=_SKIP_FP16), +]) +@pytest.mark.parametrize("shape", [ + (4, 64), # tiny refs/img + (3, 96), + (8, 128), +]) +def test_fused_matches_kernel(precision, shape): + from puzzle_sim_cuda import PuzzleSimCUDA, PuzzleSimCUDAFused + + N, S = shape + refs = torch.rand(N, 3, S, S, device="cuda") + img = torch.rand(1, 3, S, S, device="cuda") + + kernel = PuzzleSimCUDA(refs, net_type="squeeze", precision=precision) + fused = PuzzleSimCUDAFused(refs, precision=precision) + with torch.no_grad(): + out_k = kernel(img) + out_f = fused(img) + + assert out_k.shape == out_f.shape + err = _abs_err(out_k, out_f) + # tf32/fp16 multiply mode-tolerance by 3 because three layers sum into the + # final map. fp32 mode is already measured against an empirical bound that + # absorbs the conv-algorithm difference; we keep it as-is. + atol = _TOLERANCE[precision] if precision == "fp32" else _TOLERANCE[precision] * 3 + assert err <= atol, ( + f"precision={precision}, shape={shape}: max abs err {err:.3e} > {atol:.0e}" + ) + + +@requires_cuda +@requires_ext +@requires_fused +def test_fused_handles_resize(): + from puzzle_sim_cuda import PuzzleSimCUDA, PuzzleSimCUDAFused + + refs = torch.rand(5, 3, 256, 192, device="cuda") + img = torch.rand(1, 3, 256, 192, device="cuda") + + kernel = PuzzleSimCUDA(refs, net_type="squeeze", resize=(128, 96), precision="fp32") + fused = PuzzleSimCUDAFused(refs, resize=(128, 96), precision="fp32") + with torch.no_grad(): + out_k = kernel(img) + out_f = fused(img) + + assert out_k.shape == out_f.shape == img.shape[-2:] + err = _abs_err(out_k, out_f) + assert err <= _TOLERANCE["fp32"], f"resize path max abs err {err:.3e}" + + +@requires_cuda +@requires_ext +@requires_fused +def test_fused_layer_subset(): + """Picking a non-default layer set must work end-to-end.""" + from puzzle_sim_cuda import PuzzleSimCUDAFused + + refs = torch.rand(3, 3, 96, 96, device="cuda") + img = torch.rand(1, 3, 96, 96, device="cuda") + fused = PuzzleSimCUDAFused(refs, precision="fp32") + + with torch.no_grad(): + out = fused(img, layers=(0, 1, 2), weights=(0.5, 0.3, 0.2)) + assert out.shape == img.shape[-2:] + assert torch.isfinite(out).all() + + +@requires_cuda +@requires_ext +@requires_fused +def test_fused_repeated_forwards_stable(): + """Two forwards on the same input must produce identical output.""" + from puzzle_sim_cuda import PuzzleSimCUDAFused + + refs = torch.rand(3, 3, 96, 96, device="cuda") + img = torch.rand(1, 3, 96, 96, device="cuda") + fused = PuzzleSimCUDAFused(refs, precision="fp32") + + with torch.no_grad(): + a = fused(img) + b = fused(img) + assert torch.equal(a, b), "Fused forward must be deterministic across calls" + + +@requires_cuda +@requires_ext +@requires_fused +@requires_demo_data("garden") +@pytest.mark.parametrize("precision", [ + "fp32", + pytest.param("tf32", marks=_SKIP_TF32), + pytest.param("fp16", marks=_SKIP_FP16), +]) +def test_fused_garden_matches_kernel(garden_data, precision): + """End-to-end agreement on real garden images, across all precision modes.""" + from puzzle_sim_cuda import PuzzleSimCUDA, PuzzleSimCUDAFused + + assert garden_data is not None + priors, tests, _ = garden_data + img = tests[0:1] + + kernel = PuzzleSimCUDA(priors, net_type="squeeze", resize=(256, 256), precision=precision) + fused = PuzzleSimCUDAFused(priors, resize=(256, 256), precision=precision) + with torch.no_grad(): + out_k = kernel(img) + out_f = fused(img) + + assert out_k.shape == out_f.shape + assert torch.isfinite(out_f).all() + err = _abs_err(out_k, out_f) + atol = _TOLERANCE[precision] if precision == "fp32" else _TOLERANCE[precision] * 3 + assert err <= atol, f"garden / {precision}: max abs err {err:.3e} > {atol:.0e}" + + +# --------------------------------------------------------------------------- +# Factory + fallback behaviour +# --------------------------------------------------------------------------- + +@requires_cuda +@requires_ext +@requires_fused +def test_factory_dispatches_to_fused_for_squeeze(): + from puzzle_sim_cuda import PuzzleSim, PuzzleSimCUDAFused, PuzzleSimCUDA + + refs = torch.rand(2, 3, 64, 64, device="cuda") + m_fused = PuzzleSim(refs, net_type="squeeze", implementation="fused") + assert isinstance(m_fused, PuzzleSimCUDAFused) + + m_kernel = PuzzleSim(refs, net_type="squeeze", implementation="kernel") + assert isinstance(m_kernel, PuzzleSimCUDA) + + +@requires_cuda +@requires_ext +@requires_fused +def test_factory_fused_falls_back_for_non_squeeze(): + """Fused path is squeeze-only for now; alex/vgg must silently fall back.""" + from puzzle_sim_cuda import PuzzleSim, PuzzleSimCUDA + + refs = torch.rand(2, 3, 64, 64, device="cuda") + for net in ("alex", "vgg"): + m = PuzzleSim(refs, net_type=net, implementation="fused") + assert isinstance(m, PuzzleSimCUDA), \ + f"Expected fallback to PuzzleSimCUDA for {net}, got {type(m).__name__}" + + +@requires_cuda +@requires_ext +@requires_fused +def test_invalid_precision_raises(): + from puzzle_sim_cuda import PuzzleSimCUDAFused + refs = torch.rand(2, 3, 64, 64, device="cuda") + with pytest.raises(ValueError): + PuzzleSimCUDAFused(refs, precision="bf16") diff --git a/puzzle_sim_cuda/tests/test_grad.py b/puzzle_sim_cuda/tests/test_grad.py new file mode 100644 index 0000000..e02fe54 --- /dev/null +++ b/puzzle_sim_cuda/tests/test_grad.py @@ -0,0 +1,248 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Gradient / differentiable-loss tests for both PuzzleSim CUDA modes. + +PuzzleSim can be used as a perceptual loss on a *query image*: the backbone +weights and the reference distribution stay frozen, and gradients flow back to +the input. These tests verify that path end to end. + +What is covered: + +1. ``forward`` produces a graph (``requires_grad``) and ``backward`` populates a + finite, non-zero ``img.grad`` for both ``PuzzleSimCUDA`` (fp32/tf32/fp16) and + ``PuzzleSimCUDAFused``. +2. The fast inference path is unchanged: with no grad required (or under + ``torch.no_grad``) the output is detached and the custom kernels are used. +3. A finite-difference check: the analytic gradient matches a central + finite-difference estimate of the directional derivative (exact-FP32 cuDNN). +4. An Adam loop actually minimises a PuzzleSim-based loss. + +The tensor-core ``sim_max`` kernels have no backward, so whenever the query +carries grad the metric falls back to an exact FP32 ``sim_max``. That is why the +gradient tests do not need tensor-core hardware: they exercise the FP32 path +regardless of the model's nominal ``precision``. +""" + +from __future__ import annotations + +import contextlib + +import pytest +import torch + +from .conftest import requires_cuda, requires_ext, requires_demo_data + + +def _build(kind: str, refs: torch.Tensor, precision: str): + if kind == "kernel": + from puzzle_sim_cuda import PuzzleSimCUDA + + return PuzzleSimCUDA(refs, net_type="squeeze", precision=precision) + if kind == "fused": + from puzzle_sim_cuda import PuzzleSimCUDAFused + + return PuzzleSimCUDAFused(refs, precision=precision) + raise ValueError(kind) + + +@contextlib.contextmanager +def _exact_fp32_cudnn(): + """Force deterministic, non-TF32 cuDNN/cuBLAS so finite differences line up + with the analytic gradient (TF32 convs would add ~1e-3 noise).""" + prev_det = torch.backends.cudnn.deterministic + prev_cudnn_tf32 = torch.backends.cudnn.allow_tf32 + prev_mm_tf32 = torch.backends.cuda.matmul.allow_tf32 + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.allow_tf32 = False + torch.backends.cuda.matmul.allow_tf32 = False + try: + yield + finally: + torch.backends.cudnn.deterministic = prev_det + torch.backends.cudnn.allow_tf32 = prev_cudnn_tf32 + torch.backends.cuda.matmul.allow_tf32 = prev_mm_tf32 + + +_KINDS_PRECISIONS = [ + ("kernel", "fp32"), + ("kernel", "tf32"), + ("kernel", "fp16"), + ("fused", "tf32"), +] + + +# --------------------------------------------------------------------------- +# 1. The output is differentiable w.r.t. the query image +# --------------------------------------------------------------------------- + +@requires_cuda +@requires_ext +@pytest.mark.parametrize("kind,precision", _KINDS_PRECISIONS) +def test_backward_populates_query_grad(kind, precision): + refs = torch.rand(4, 3, 64, 64, device="cuda") + model = _build(kind, refs, precision) + + img = torch.rand(1, 3, 64, 64, device="cuda", requires_grad=True) + out = model(img) + assert out.requires_grad, f"{kind}/{precision}: output is detached" + + loss = -out.mean() + loss.backward() + + assert img.grad is not None, f"{kind}/{precision}: no grad produced" + assert torch.isfinite(img.grad).all(), f"{kind}/{precision}: non-finite grad" + assert img.grad.abs().max() > 0, f"{kind}/{precision}: grad is identically zero" + + +@requires_cuda +@requires_ext +@pytest.mark.parametrize("kind,precision", _KINDS_PRECISIONS) +def test_references_and_weights_stay_frozen(kind, precision): + """Only the query image should accumulate grad; the model is frozen.""" + refs = torch.rand(3, 3, 64, 64, device="cuda") + model = _build(kind, refs, precision) + + img = torch.rand(1, 3, 64, 64, device="cuda", requires_grad=True) + (-model(img).mean()).backward() + + trainable = [p for p in model.parameters() if p.requires_grad] + assert not trainable, f"{kind}/{precision}: backbone params are not frozen" + + +# --------------------------------------------------------------------------- +# 2. The fast inference path is untouched +# --------------------------------------------------------------------------- + +@requires_cuda +@requires_ext +@pytest.mark.parametrize("kind,precision", _KINDS_PRECISIONS) +def test_inference_output_is_detached(kind, precision): + refs = torch.rand(3, 3, 64, 64, device="cuda") + model = _build(kind, refs, precision) + + img = torch.rand(1, 3, 64, 64, device="cuda") # no requires_grad + out = model(img) + assert not out.requires_grad, f"{kind}/{precision}: inference output carries grad" + + +@requires_cuda +@requires_ext +@pytest.mark.parametrize("kind,precision", _KINDS_PRECISIONS) +def test_no_grad_context_uses_fast_path(kind, precision): + """Even a leaf that requires grad is detached under ``torch.no_grad``.""" + refs = torch.rand(3, 3, 64, 64, device="cuda") + model = _build(kind, refs, precision) + + img = torch.rand(1, 3, 64, 64, device="cuda", requires_grad=True) + with torch.no_grad(): + out = model(img) + assert not out.requires_grad, f"{kind}/{precision}: grad recorded under no_grad" + + +# --------------------------------------------------------------------------- +# 3. Finite-difference check of the analytic gradient +# --------------------------------------------------------------------------- + +@requires_cuda +@requires_ext +@pytest.mark.parametrize("kind", ["kernel", "fused"]) +def test_finite_difference_directional(kind): + """Central finite difference of the directional derivative along the + gradient direction must match the analytic gradient norm. + + Using ``v = g/||g||`` gives the strongest directional signal (best SNR for + a finite-difference probe through a deep network).""" + torch.manual_seed(0) + refs = torch.rand(2, 3, 32, 32, device="cuda") + model = _build(kind, refs, "fp32") + + def loss_value(x: torch.Tensor) -> float: + # Fresh leaf -> differentiable (PyTorch-op) path, matching the analytic + # forward exactly. We only need the scalar value here. + xr = x.detach().requires_grad_(True) + with torch.enable_grad(): + return float(model(xr, normalize=True).sum().item()) + + with _exact_fp32_cudnn(): + base = torch.rand(1, 3, 32, 32, device="cuda") + + img = base.detach().requires_grad_(True) + with torch.enable_grad(): + loss = model(img, normalize=True).sum() + loss.backward() + g = img.grad + assert g is not None + gnorm = g.norm() + assert gnorm > 1e-4 + + v = g / gnorm + eps = 2e-3 + f_plus = loss_value(base + eps * v) + f_minus = loss_value(base - eps * v) + dd_fd = (f_plus - f_minus) / (2 * eps) + dd_analytic = float(gnorm.item()) # (g . v) == ||g|| + + rel = abs(dd_fd - dd_analytic) / max(abs(dd_analytic), 1e-6) + assert rel < 5e-2, ( + f"{kind}: directional FD {dd_fd:.4f} vs analytic {dd_analytic:.4f} " + f"(rel err {rel:.3%})" + ) + + +# --------------------------------------------------------------------------- +# 4. PuzzleSim is minimisable as a loss +# --------------------------------------------------------------------------- + +@requires_cuda +@requires_ext +@pytest.mark.parametrize("kind,precision", _KINDS_PRECISIONS) +def test_adam_reduces_loss(kind, precision): + """Optimising an image to *increase* similarity reduces ``-sim.mean()``.""" + refs = torch.rand(4, 3, 64, 64, device="cuda") + model = _build(kind, refs, precision) + + img = torch.rand(1, 3, 64, 64, device="cuda", requires_grad=True) + opt = torch.optim.Adam([img], lr=5e-2) + + losses = [] + for _ in range(40): + opt.zero_grad() + loss = -model(img).mean() + loss.backward() + opt.step() + with torch.no_grad(): + img.clamp_(0.0, 1.0) + losses.append(loss.item()) + + assert all(torch.isfinite(torch.tensor(losses))) + # Final loss is clearly below the start, and the tail is below the head. + assert losses[-1] < losses[0] - 1e-3, f"{kind}/{precision}: no progress {losses[0]:.4f}->{losses[-1]:.4f}" + assert sum(losses[-5:]) / 5 < sum(losses[:5]) / 5, f"{kind}/{precision}: not trending down" + + +@requires_cuda +@requires_ext +@requires_demo_data("garden") +def test_adam_reduces_loss_real_data(garden_data): + """Same optimisation sanity check on a real reference distribution.""" + from puzzle_sim_cuda import PuzzleSimCUDA + + assert garden_data is not None + priors, tests, _ = garden_data + model = PuzzleSimCUDA(priors, net_type="squeeze", resize=(128, 128), precision="fp32") + + img = tests[0:1].clone().detach().requires_grad_(True) + opt = torch.optim.Adam([img], lr=2e-2) + + first = last = None + for step in range(25): + opt.zero_grad() + loss = -model(img).mean() + loss.backward() + opt.step() + with torch.no_grad(): + img.clamp_(0.0, 1.0) + if step == 0: + first = loss.item() + last = loss.item() + + assert last < first, f"loss did not decrease: {first:.4f} -> {last:.4f}" diff --git a/puzzle_sim_cuda/tests/test_kernels.py b/puzzle_sim_cuda/tests/test_kernels.py new file mode 100644 index 0000000..322a28b --- /dev/null +++ b/puzzle_sim_cuda/tests/test_kernels.py @@ -0,0 +1,152 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Per-kernel correctness tests. + +Each kernel is compared against an obvious PyTorch reference implementation +of the same operation. We use float32 throughout, so the tolerance is set just +above the rounding floor for the corresponding op. +""" + +from __future__ import annotations + +import pytest +import torch + +from .conftest import requires_cuda, requires_ext + + +def _normalize_ref(x: torch.Tensor, eps: float = 1e-8) -> torch.Tensor: + return x / torch.sqrt(eps + x.pow(2).sum(dim=1, keepdim=True)) + + +# --------------------------------------------------------------------------- +# normalize_features +# --------------------------------------------------------------------------- + +@requires_cuda +@requires_ext +@pytest.mark.parametrize("shape", [ + (1, 64, 16, 16), + (4, 128, 32, 32), + (8, 256, 8, 8), + (1, 384, 64, 64), + (3, 512, 7, 9), # non-square spatial +]) +def test_normalize_features_matches_pytorch(shape): + import puzzle_sim_cuda_ext as ext + + x = torch.randn(*shape, device="cuda", dtype=torch.float32) + ref = _normalize_ref(x) + out = ext.normalize_features(x.contiguous(), 1e-8) + + assert out.shape == ref.shape + assert torch.allclose(out, ref, atol=1e-6, rtol=1e-5) + + +@requires_cuda +@requires_ext +def test_normalize_features_unit_norm(): + """L2 norm along channels must be ~1 after normalization.""" + import puzzle_sim_cuda_ext as ext + x = torch.randn(2, 64, 16, 16, device="cuda", dtype=torch.float32) + out = ext.normalize_features(x.contiguous(), 1e-8) + norms = out.pow(2).sum(dim=1).sqrt() + assert torch.allclose(norms, torch.ones_like(norms), atol=1e-5) + + +# --------------------------------------------------------------------------- +# pack_reference +# --------------------------------------------------------------------------- + +@requires_cuda +@requires_ext +@pytest.mark.parametrize("shape", [(4, 32, 6, 6), (1, 128, 8, 8), (10, 256, 16, 16)]) +def test_pack_reference_layout(shape): + import puzzle_sim_cuda_ext as ext + refs = torch.randn(*shape, device="cuda", dtype=torch.float32) + packed = ext.pack_reference(refs.contiguous()) + N, C, H, W = shape + assert packed.shape == (C, N * H * W) + # Equivalent to transpose+flatten in torch. + expected = refs.transpose(0, 1).contiguous().reshape(C, N * H * W) + assert torch.equal(packed, expected) + + +# --------------------------------------------------------------------------- +# _sim_max (Python-side, cuBLAS-backed) +# --------------------------------------------------------------------------- + +@requires_cuda +@pytest.mark.parametrize("N,C,H,W", [ + (1, 32, 8, 8), + (5, 64, 8, 8), + (10, 128, 16, 16), + (1, 256, 32, 32), + (3, 256, 13, 11), # awkward spatial sizes + (8, 512, 4, 4), + (36, 256, 52, 78), # ~garden layer 2; large enough that chunking kicks in +]) +def test_sim_max_matches_matmul(N, C, H, W): + from puzzle_sim_cuda.puzzle_sim_cuda import _sim_max, _pack_reference + + refs = torch.randn(N, C, H, W, device="cuda", dtype=torch.float32) + q = torch.randn(C, H, W, device="cuda", dtype=torch.float32) + + refs = refs / torch.sqrt(1e-8 + refs.pow(2).sum(dim=1, keepdim=True)) + qn = q / torch.sqrt(1e-8 + q.pow(2).sum(dim=0, keepdim=True)) + + packed = _pack_reference(refs.contiguous()) + out = _sim_max(qn, packed, (H, W)) + + # PyTorch reference: full GEMM + row-wise max. + qp = qn.reshape(C, H * W).contiguous() + refs_flat = refs.transpose(0, 1).contiguous().reshape(C, N * H * W) + scores = qp.T @ refs_flat + expected = scores.max(dim=1).values.reshape(H, W) + + assert out.shape == expected.shape + assert torch.allclose(out, expected, atol=1e-5, rtol=1e-5) + + +@requires_cuda +def test_sim_max_self_similarity_is_one(): + """When the query is one of the references, the per-pixel max must be 1 + (within float epsilon) because each query pixel matches itself exactly.""" + from puzzle_sim_cuda.puzzle_sim_cuda import _sim_max, _pack_reference + + N, C, H, W = 3, 64, 8, 8 + refs = torch.randn(N, C, H, W, device="cuda", dtype=torch.float32) + refs = refs / torch.sqrt(1e-8 + refs.pow(2).sum(dim=1, keepdim=True)) + packed = _pack_reference(refs.contiguous()) + + out = _sim_max(refs[0], packed, (H, W)) + + assert torch.allclose(out, torch.ones_like(out), atol=1e-5) + + +# --------------------------------------------------------------------------- +# bilinear_upsample +# --------------------------------------------------------------------------- + +@requires_cuda +@requires_ext +@pytest.mark.parametrize("in_hw,out_hw,align", [ + ((8, 8), (64, 64), True), + ((16, 16), (128, 128), True), + ((6, 9), (32, 48), True), + ((8, 8), (33, 41), True), + ((8, 8), (64, 64), False), +]) +def test_bilinear_upsample_matches_torch(in_hw, out_hw, align): + import puzzle_sim_cuda_ext as ext + + x = torch.randn(*in_hw, device="cuda", dtype=torch.float32) + out = ext.bilinear_upsample(x.contiguous(), list(out_hw), align) + expected = torch.nn.functional.interpolate( + x.unsqueeze(0).unsqueeze(0), + size=out_hw, + mode="bilinear", + align_corners=align, + ).squeeze(0).squeeze(0) + + assert out.shape == expected.shape + assert torch.allclose(out, expected, atol=1e-5, rtol=1e-5) diff --git a/puzzle_sim_cuda/tests/test_puzzlesim.py b/puzzle_sim_cuda/tests/test_puzzlesim.py new file mode 100644 index 0000000..643d223 --- /dev/null +++ b/puzzle_sim_cuda/tests/test_puzzlesim.py @@ -0,0 +1,138 @@ +# SPDX-License-Identifier: Apache-2.0 +"""End-to-end correctness tests of ``PuzzleSimCUDA`` against the reference +PyTorch implementation in ``puzzle_sim.PuzzleSim``. + +These tests pin ``precision="fp32"`` so any drift is purely from reduction- +order changes in our matmul + max chunking (not from TF32 / FP16 rounding). +The relaxed-precision paths are exercised in :mod:`test_tensor_cores`. +""" + +from __future__ import annotations + +import pytest +import torch + +from .conftest import requires_cuda, requires_ext + + +def _make_inputs(num_refs: int, hw: tuple[int, int]) -> tuple[torch.Tensor, torch.Tensor]: + refs = torch.rand(num_refs, 3, *hw, device="cuda") + img = torch.rand(1, 3, *hw, device="cuda") + return refs, img + + +def _run_ref(refs: torch.Tensor, img: torch.Tensor, **kwargs) -> torch.Tensor: + from puzzle_sim import PuzzleSim as RefPuzzleSim + model = RefPuzzleSim(refs, **kwargs).to(refs.device).eval() + with torch.no_grad(): + return model(img) + + +def _run_cuda(refs: torch.Tensor, img: torch.Tensor, **kwargs) -> torch.Tensor: + from puzzle_sim_cuda import PuzzleSimCUDA + kwargs.setdefault("precision", "fp32") + model = PuzzleSimCUDA(refs, **kwargs) + with torch.no_grad(): + return model(img) + + +@requires_cuda +@requires_ext +@pytest.mark.parametrize("net_type", ["squeeze", "alex", "vgg"]) +def test_matches_reference_on_random_inputs(net_type): + """End-to-end agreement across the three supported backbones.""" + refs, img = _make_inputs(num_refs=5, hw=(96, 96)) + ref_out = _run_ref(refs, img, net_type=net_type) + cuda_out = _run_cuda(refs, img, net_type=net_type) + + assert ref_out.shape == cuda_out.shape + rel = (ref_out - cuda_out).abs().max() / ref_out.abs().max().clamp_min(1e-9) + assert rel.item() < 1e-4, ( + f"net={net_type} relative error too high: {rel.item():.3e}" + ) + + +@requires_cuda +@requires_ext +@pytest.mark.parametrize("hw", [(64, 64), (96, 128), (128, 96), (160, 160)]) +def test_matches_reference_across_input_shapes(hw): + refs, img = _make_inputs(num_refs=4, hw=hw) + ref_out = _run_ref(refs, img, net_type="squeeze") + cuda_out = _run_cuda(refs, img, net_type="squeeze") + assert ref_out.shape == (hw[0], hw[1]) + assert cuda_out.shape == (hw[0], hw[1]) + rel = (ref_out - cuda_out).abs().max() / ref_out.abs().max().clamp_min(1e-9) + assert rel.item() < 1e-4 + + +@requires_cuda +@requires_ext +def test_matches_reference_with_resize(): + refs, img = _make_inputs(num_refs=5, hw=(160, 160)) + ref_out = _run_ref(refs, img, net_type="squeeze", resize=(96, 96)) + cuda_out = _run_cuda(refs, img, net_type="squeeze", resize=(96, 96)) + assert ref_out.shape == cuda_out.shape + rel = (ref_out - cuda_out).abs().max() / ref_out.abs().max().clamp_min(1e-9) + assert rel.item() < 1e-4 + + +@requires_cuda +@requires_ext +def test_self_image_is_high_similarity(): + """An image that is itself one of the references should score very high.""" + refs, _ = _make_inputs(num_refs=4, hw=(96, 96)) + img = refs[0:1].clone() + out = _run_cuda(refs, img, net_type="squeeze") + # The default weights sum to 1.0, so a "perfect" match would give ~1.0. + assert out.mean().item() > 0.95 + + +@requires_cuda +@requires_ext +def test_caches_reference_features_across_calls(): + """Second forward pass should reuse the packed reference cache.""" + from puzzle_sim_cuda import PuzzleSimCUDA + + refs, img = _make_inputs(num_refs=4, hw=(96, 96)) + model = PuzzleSimCUDA(refs, net_type="squeeze", precision="fp32") + with torch.no_grad(): + out1 = model(img) + # Mutate the underlying reference tensor. The cached features must + # still be used (we intentionally do not invalidate the cache to + # match the reference implementation's behaviour). + refs.zero_() + out2 = model(img) + assert torch.allclose(out1, out2) + + +@requires_cuda +@requires_ext +def test_reduction_modes(): + """Mean reduction must equal sum reduction divided by the layer count.""" + refs, img = _make_inputs(num_refs=3, hw=(96, 96)) + from puzzle_sim_cuda import PuzzleSimCUDA + model = PuzzleSimCUDA(refs, net_type="squeeze", precision="fp32") + with torch.no_grad(): + s = model(img, reduction="sum") + m = model(img, reduction="mean") + # With default layers=(2,3,4), mean = sum / 3. + assert torch.allclose(m, s / 3.0, atol=1e-6, rtol=1e-5) + + +@requires_cuda +@requires_ext +def test_weights_validation(): + refs, img = _make_inputs(num_refs=2, hw=(96, 96)) + from puzzle_sim_cuda import PuzzleSimCUDA + model = PuzzleSimCUDA(refs, net_type="squeeze", precision="fp32") + with pytest.raises(ValueError): + model(img, layers=(2, 3, 4), weights=(0.5, 0.5)) + + +@requires_cuda +@requires_ext +def test_invalid_net_type_raises(): + refs, _ = _make_inputs(num_refs=2, hw=(96, 96)) + from puzzle_sim_cuda import PuzzleSimCUDA + with pytest.raises(ValueError): + PuzzleSimCUDA(refs, net_type="not-a-real-net") diff --git a/puzzle_sim_cuda/tests/test_real_data.py b/puzzle_sim_cuda/tests/test_real_data.py new file mode 100644 index 0000000..37c16e2 --- /dev/null +++ b/puzzle_sim_cuda/tests/test_real_data.py @@ -0,0 +1,148 @@ +# SPDX-License-Identifier: Apache-2.0 +"""End-to-end correctness tests on real image data. + +These tests exercise ``PuzzleSimCUDA`` against ``puzzle_sim.PuzzleSim`` on the +garden dataset (36 priors + 4 test images, all 628x416 RGB). + +They are slower than the random-tensor tests in :mod:`test_puzzlesim` so we +keep the matrix small (one or two test images, one or two configurations). +The point of these tests is to catch regressions that only surface on real +data - e.g. denormals, NaNs from edge pixels, or layout assumptions that +break on non-square inputs. +""" + +from __future__ import annotations + +import pytest +import torch + +from .conftest import requires_cuda, requires_ext, requires_demo_data + + +def _relative_error(a: torch.Tensor, b: torch.Tensor) -> float: + return ( + (a - b).abs().max() / a.abs().max().clamp_min(1e-9) + ).item() + + +@requires_cuda +@requires_ext +@requires_demo_data("garden") +@pytest.mark.parametrize("resize", [None, (256, 256), (128, 128)]) +def test_garden_matches_reference(garden_data, resize): + """Full PuzzleSim on the garden dataset must match the PyTorch reference. + + We use the first test image only (the others would just multiply runtime + by 4 without exercising any new code path). + """ + from puzzle_sim import PuzzleSim as RefPuzzleSim + from puzzle_sim_cuda import PuzzleSimCUDA + + assert garden_data is not None + priors, tests, _ = garden_data + img = tests[0:1] + + ref_model = RefPuzzleSim(priors, net_type="squeeze", resize=resize).to(priors.device).eval() + cuda_model = PuzzleSimCUDA(priors, net_type="squeeze", resize=resize, precision="fp32") + + with torch.no_grad(): + ref_out = ref_model(img) + cuda_out = cuda_model(img) + + assert ref_out.shape == cuda_out.shape == img.shape[-2:] + assert torch.isfinite(cuda_out).all(), "CUDA output contains NaN/Inf" + rel = _relative_error(ref_out, cuda_out) + assert rel < 1e-4, f"resize={resize!r}: relative error too high: {rel:.3e}" + + +@requires_cuda +@requires_ext +@requires_demo_data("garden") +def test_garden_all_test_images(garden_data): + """Every test image in the dataset should match the reference.""" + from puzzle_sim import PuzzleSim as RefPuzzleSim + from puzzle_sim_cuda import PuzzleSimCUDA + + assert garden_data is not None + priors, tests, names = garden_data + + ref_model = RefPuzzleSim(priors, net_type="squeeze", resize=(256, 256)).to(priors.device).eval() + cuda_model = PuzzleSimCUDA(priors, net_type="squeeze", resize=(256, 256), precision="fp32") + + for i, name in enumerate(names): + img = tests[i:i + 1] + with torch.no_grad(): + ref_out = ref_model(img) + cuda_out = cuda_model(img) + rel = _relative_error(ref_out, cuda_out) + assert rel < 1e-4, f"{name}: relative error {rel:.3e}" + + +@requires_cuda +@requires_ext +@requires_demo_data("garden") +@pytest.mark.parametrize("net_type", ["squeeze", "alex", "vgg"]) +def test_garden_all_backbones(garden_data, net_type): + """All three backbones must work on the real-data path.""" + from puzzle_sim import PuzzleSim as RefPuzzleSim + from puzzle_sim_cuda import PuzzleSimCUDA + + assert garden_data is not None + priors, tests, _ = garden_data + img = tests[0:1] + + ref_model = RefPuzzleSim(priors, net_type=net_type, resize=(256, 256)).to(priors.device).eval() + cuda_model = PuzzleSimCUDA(priors, net_type=net_type, resize=(256, 256), precision="fp32") + + with torch.no_grad(): + ref_out = ref_model(img) + cuda_out = cuda_model(img) + + rel = _relative_error(ref_out, cuda_out) + assert rel < 1e-4, f"net={net_type}: relative error {rel:.3e}" + + +@requires_cuda +@requires_ext +@requires_demo_data("garden") +def test_garden_output_is_a_valid_similarity_map(garden_data): + """Sanity-check the metric values themselves. + + With default ``weights=(0.67, 0.2, 0.13)`` (sum == 1.0) and cosine + similarities in [-1, 1], the per-pixel score is bounded in [-1, 1]. + On natural images we expect to be solidly in [0, 1]. + """ + from puzzle_sim_cuda import PuzzleSimCUDA + + assert garden_data is not None + priors, tests, _ = garden_data + + cuda_model = PuzzleSimCUDA(priors, net_type="squeeze", resize=(256, 256)) + with torch.no_grad(): + out = cuda_model(tests[0:1]) + + assert torch.isfinite(out).all() + assert out.min().item() >= -1.0 + assert out.max().item() <= 1.0 + 1e-5 + assert out.mean().item() > 0.5, "expected high similarity on natural data" + + +@requires_cuda +@requires_ext +@requires_demo_data("garden") +def test_garden_self_image_high_similarity(garden_data): + """An image that is itself one of the priors should produce a very high + average similarity. This catches algorithmic mistakes that would otherwise + only show up as small numerical disagreement with the reference.""" + from puzzle_sim_cuda import PuzzleSimCUDA + + assert garden_data is not None + priors, _, _ = garden_data + + cuda_model = PuzzleSimCUDA(priors, net_type="squeeze", resize=(256, 256)) + with torch.no_grad(): + out = cuda_model(priors[0:1]) + + assert out.mean().item() > 0.95, ( + f"self-image average similarity should be ~1, got {out.mean().item():.3f}" + ) diff --git a/puzzle_sim_cuda/tests/test_tensor_cores.py b/puzzle_sim_cuda/tests/test_tensor_cores.py new file mode 100644 index 0000000..cb67522 --- /dev/null +++ b/puzzle_sim_cuda/tests/test_tensor_cores.py @@ -0,0 +1,216 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Correctness tests for the tensor-core sim_max kernel. + +These verify two things, mode by mode: + +1. The kernel-level wrapper ``_sim_max(..., precision=p)`` agrees with the + reference ``(Q.T @ R).max(dim=1)`` within the tolerance expected for the + precision mode. +2. The full ``PuzzleSimCUDA`` model with ``precision={'tf32','fp16'}`` produces + the same output as ``precision='fp32'`` within the same tolerance. + +Tolerances: + +* fp32: atol=1e-5 (rounding floor) +* tf32: atol=1e-3 (10-bit mantissa with FP32 accumulator) +* fp16: atol=5e-3 (5-bit exponent + 10-bit mantissa with FP32 accumulator) +""" + +from __future__ import annotations + +import pytest +import torch + +from .conftest import requires_cuda, requires_ext, requires_demo_data + + +_TOLERANCE = {"fp32": 1e-5, "tf32": 1e-3, "fp16": 5e-3} + + +def _device_capability_at_least(major: int, minor: int = 0) -> bool: + if not torch.cuda.is_available(): + return False + cap = torch.cuda.get_device_capability() + return cap >= (major, minor) + + +_SKIP_TF32 = pytest.mark.skipif( + not _device_capability_at_least(8), + reason="TF32 tensor cores require compute capability >= 8.0", +) +_SKIP_FP16 = pytest.mark.skipif( + not _device_capability_at_least(7), + reason="FP16 tensor cores require compute capability >= 7.0", +) + + +def _reference_sim_max(Q: torch.Tensor, R: torch.Tensor) -> torch.Tensor: + return (Q.T @ R).max(dim=1).values + + +def _refs_for_precision(packed_fp32: torch.Tensor, precision: str) -> torch.Tensor: + if precision == "fp16": + return packed_fp32.half().contiguous() + return packed_fp32 + + +# --------------------------------------------------------------------------- +# Kernel-level: _sim_max in each mode +# --------------------------------------------------------------------------- + +@requires_cuda +@requires_ext +@pytest.mark.parametrize("precision", ["fp32", + pytest.param("tf32", marks=_SKIP_TF32), + pytest.param("fp16", marks=_SKIP_FP16)]) +@pytest.mark.parametrize("N,C,H,W", [ + (1, 32, 8, 8), # small + (10, 128, 16, 16), # mid + (1, 256, 32, 32), # bigger qHW + (3, 256, 13, 11), # non-power-of-two + (8, 512, 4, 4), + (36, 256, 52, 78), # garden-layer-2 scale +]) +def test_sim_max_matches_matmul_for_each_precision(precision, N, C, H, W): + from puzzle_sim_cuda.puzzle_sim_cuda import _sim_max, _pack_reference + + refs = torch.randn(N, C, H, W, device="cuda", dtype=torch.float32) + q = torch.randn(C, H, W, device="cuda", dtype=torch.float32) + refs = refs / torch.sqrt(1e-8 + refs.pow(2).sum(dim=1, keepdim=True)) + qn = q / torch.sqrt(1e-8 + q.pow(2).sum(dim=0, keepdim=True)) + + packed = _pack_reference(refs.contiguous()) + refs_for_p = _refs_for_precision(packed, precision) + + out = _sim_max(qn, refs_for_p, (H, W), precision=precision) + + qp = qn.reshape(C, H * W).contiguous() + refs_flat = refs.transpose(0, 1).contiguous().reshape(C, N * H * W) + expected = _reference_sim_max(qp, refs_flat).reshape(H, W) + + atol = _TOLERANCE[precision] + max_err = (out - expected).abs().max().item() + assert max_err <= atol, ( + f"precision={precision}: max_err={max_err:.3e} exceeds tolerance {atol:.0e}" + ) + + +@requires_cuda +@requires_ext +@_SKIP_TF32 +def test_sim_max_tf32_self_similarity_is_one(): + """When the query is a ref, the per-pixel max must be ~1 even for tf32.""" + from puzzle_sim_cuda.puzzle_sim_cuda import _sim_max, _pack_reference + + N, C, H, W = 3, 64, 8, 8 + refs = torch.randn(N, C, H, W, device="cuda", dtype=torch.float32) + refs = refs / torch.sqrt(1e-8 + refs.pow(2).sum(dim=1, keepdim=True)) + packed = _pack_reference(refs.contiguous()) + + out = _sim_max(refs[0], packed, (H, W), precision="tf32") + assert torch.allclose(out, torch.ones_like(out), atol=_TOLERANCE["tf32"]) + + +@requires_cuda +@requires_ext +@_SKIP_FP16 +def test_sim_max_fp16_self_similarity_is_one(): + from puzzle_sim_cuda.puzzle_sim_cuda import _sim_max, _pack_reference + + N, C, H, W = 3, 64, 8, 8 + refs = torch.randn(N, C, H, W, device="cuda", dtype=torch.float32) + refs = refs / torch.sqrt(1e-8 + refs.pow(2).sum(dim=1, keepdim=True)) + packed = _pack_reference(refs.contiguous()).half().contiguous() + + out = _sim_max(refs[0], packed, (H, W), precision="fp16") + assert torch.allclose(out, torch.ones_like(out), atol=_TOLERANCE["fp16"]) + + +# --------------------------------------------------------------------------- +# End-to-end: PuzzleSimCUDA in each mode against fp32 baseline +# --------------------------------------------------------------------------- + +def _abs_err(a: torch.Tensor, b: torch.Tensor) -> float: + return (a - b).abs().max().item() + + +@requires_cuda +@requires_ext +@pytest.mark.parametrize("precision", + [pytest.param("tf32", marks=_SKIP_TF32), + pytest.param("fp16", marks=_SKIP_FP16)]) +def test_puzzlesim_matches_fp32_baseline(precision): + """End-to-end ``PuzzleSimCUDA`` agreement between fp32 and {tf32, fp16}.""" + from puzzle_sim_cuda import PuzzleSimCUDA + + refs = torch.rand(4, 3, 96, 96, device="cuda") + img = torch.rand(1, 3, 96, 96, device="cuda") + + baseline = PuzzleSimCUDA(refs, net_type="squeeze", precision="fp32") + model = PuzzleSimCUDA(refs, net_type="squeeze", precision=precision) + with torch.no_grad(): + out_fp32 = baseline(img) + out_tc = model(img) + + err = _abs_err(out_fp32, out_tc) + # Relax the tolerance a little here vs the kernel-level test; the metric + # sums three layers (each gets to drift by ~atol/3) and then bilinearly + # upsamples, which doesn't add error but slightly smears it. + atol = _TOLERANCE[precision] * 3 + assert err <= atol, f"precision={precision}: max abs err {err:.3e} > {atol:.0e}" + + +@requires_cuda +@requires_ext +@requires_demo_data("garden") +@pytest.mark.parametrize("precision", + [pytest.param("tf32", marks=_SKIP_TF32), + pytest.param("fp16", marks=_SKIP_FP16)]) +def test_puzzlesim_garden_matches_fp32_baseline(garden_data, precision): + """Same end-to-end agreement test on real images at the garden scale.""" + from puzzle_sim_cuda import PuzzleSimCUDA + + assert garden_data is not None + priors, tests, _ = garden_data + img = tests[0:1] + + baseline = PuzzleSimCUDA(priors, net_type="squeeze", resize=(256, 256), precision="fp32") + model = PuzzleSimCUDA(priors, net_type="squeeze", resize=(256, 256), precision=precision) + with torch.no_grad(): + out_fp32 = baseline(img) + out_tc = model(img) + + err = _abs_err(out_fp32, out_tc) + atol = _TOLERANCE[precision] * 3 + assert torch.isfinite(out_tc).all() + assert err <= atol, f"precision={precision}: max abs err {err:.3e} > {atol:.0e}" + + +# --------------------------------------------------------------------------- +# Behaviour guarantees: graceful fallback / explicit dispatch +# --------------------------------------------------------------------------- + +@requires_cuda +@requires_ext +def test_invalid_precision_raises(): + from puzzle_sim_cuda import PuzzleSimCUDA + refs = torch.rand(2, 3, 64, 64, device="cuda") + with pytest.raises(ValueError): + PuzzleSimCUDA(refs, net_type="squeeze", precision="bf16") + + +@requires_cuda +@requires_ext +@_SKIP_FP16 +def test_fp16_uses_fp16_cached_refs(): + """Calling forward with precision='fp16' must cache an FP16 copy of refs.""" + from puzzle_sim_cuda import PuzzleSimCUDA + + refs = torch.rand(3, 3, 64, 64, device="cuda") + img = torch.rand(1, 3, 64, 64, device="cuda") + model = PuzzleSimCUDA(refs, net_type="squeeze", precision="fp16") + with torch.no_grad(): + _ = model(img) + assert len(model._packed_refs_fp16) >= 1 + for v in model._packed_refs_fp16.values(): + assert v.dtype == torch.float16 From eb432136e30d476bcdd57d083251a39a5b238337 Mon Sep 17 00:00:00 2001 From: nihermann Date: Fri, 3 Jul 2026 16:31:29 +0200 Subject: [PATCH 2/2] refactored the cuda implementation based on the initial puzzle sim version to the latest version. Everything is now in one project and coupled. Compute backend choices are automated such that the user will not need to pick himself --- .github/workflows/release.yml | 58 ++ .gitignore | 14 +- README.md | 55 +- demo.ipynb | 296 +++------- puzzle_sim_cuda/README.md | 430 -------------- puzzle_sim_cuda/__init__.py | 30 - puzzle_sim_cuda/benchmark.py | 548 ------------------ puzzle_sim_cuda/build.py | 54 -- puzzle_sim_cuda/examples/loss_demo.py | 174 ------ puzzle_sim_cuda/puzzle_sim_cuda.py | 432 -------------- puzzle_sim_cuda/puzzle_sim_cuda_fused.py | 245 -------- puzzle_sim_cuda/requirements.txt | 17 - puzzle_sim_cuda/setup.py | 62 -- puzzle_sim_cuda/src/fused_inference.cpp | 529 ----------------- puzzle_sim_cuda/tests/__init__.py | 0 puzzle_sim_cuda/tests/conftest.py | 98 ---- puzzle_sim_cuda/tests/test_fused.py | 271 --------- puzzle_sim_cuda/tests/test_grad.py | 248 -------- puzzle_sim_cuda/tests/test_kernels.py | 152 ----- puzzle_sim_cuda/tests/test_puzzlesim.py | 138 ----- puzzle_sim_cuda/tests/test_real_data.py | 148 ----- puzzle_sim_cuda/tests/test_tensor_cores.py | 216 ------- pyproject.toml | 6 +- setup.py | 66 +++ src/puzzle_sim/__init__.py | 96 ++- src/puzzle_sim/cuda_backend.py | 294 ++++++++++ .../puzzle_sim/cuda_ext}/kernels.cu | 0 .../puzzle_sim/cuda_ext}/puzzle_sim_cuda.cpp | 7 - test_cuda_backend.py | 43 ++ 29 files changed, 687 insertions(+), 4040 deletions(-) create mode 100644 .github/workflows/release.yml delete mode 100644 puzzle_sim_cuda/README.md delete mode 100644 puzzle_sim_cuda/__init__.py delete mode 100644 puzzle_sim_cuda/benchmark.py delete mode 100644 puzzle_sim_cuda/build.py delete mode 100644 puzzle_sim_cuda/examples/loss_demo.py delete mode 100644 puzzle_sim_cuda/puzzle_sim_cuda.py delete mode 100644 puzzle_sim_cuda/puzzle_sim_cuda_fused.py delete mode 100644 puzzle_sim_cuda/requirements.txt delete mode 100644 puzzle_sim_cuda/setup.py delete mode 100644 puzzle_sim_cuda/src/fused_inference.cpp delete mode 100644 puzzle_sim_cuda/tests/__init__.py delete mode 100644 puzzle_sim_cuda/tests/conftest.py delete mode 100644 puzzle_sim_cuda/tests/test_fused.py delete mode 100644 puzzle_sim_cuda/tests/test_grad.py delete mode 100644 puzzle_sim_cuda/tests/test_kernels.py delete mode 100644 puzzle_sim_cuda/tests/test_puzzlesim.py delete mode 100644 puzzle_sim_cuda/tests/test_real_data.py delete mode 100644 puzzle_sim_cuda/tests/test_tensor_cores.py create mode 100644 setup.py create mode 100644 src/puzzle_sim/cuda_backend.py rename {puzzle_sim_cuda/src => src/puzzle_sim/cuda_ext}/kernels.cu (100%) rename {puzzle_sim_cuda/src => src/puzzle_sim/cuda_ext}/puzzle_sim_cuda.cpp (97%) create mode 100644 test_cuda_backend.py diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..2c61846 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,58 @@ +name: Release + +on: + release: + types: [published] + workflow_dispatch: + +permissions: + contents: read + +jobs: + build: + name: Build package + runs-on: ubuntu-latest + + steps: + - name: Check out + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.12" + + - name: Build artifacts + run: | + python -m pip install --upgrade pip + python -m pip install build twine + python -m build + python -m twine check dist/* + + - name: Upload artifacts + uses: actions/upload-artifact@v4 + with: + name: python-package + path: dist/* + + publish: + name: Publish to PyPI + if: github.event_name == 'release' + needs: build + runs-on: ubuntu-latest + environment: pypi + permissions: + contents: read + id-token: write + + steps: + - name: Download artifacts + uses: actions/download-artifact@v4 + with: + name: python-package + path: dist + + - name: Publish package + uses: pypa/gh-action-pypi-publish@release/v1 diff --git a/.gitignore b/.gitignore index 19bc0b9..51bfd78 100644 --- a/.gitignore +++ b/.gitignore @@ -1,15 +1,15 @@ .idea .vscode __pycache__ +*.egg-info/ +*.pyc +*.pyd +*.so +*.whl +build/ +dist/ .DS_Store -# Compiled CUDA extension and build artifacts -puzzle_sim_cuda/build/ -puzzle_sim_cuda/dist/ -puzzle_sim_cuda/*.egg-info/ -puzzle_sim_cuda/*.pyd -puzzle_sim_cuda/*.so -puzzle_sim_cuda/*.log .pytest_cache/ puzzle_sim\lpips_models\alex.pth diff --git a/README.md b/README.md index 83fbfe1..daa3da6 100644 --- a/README.md +++ b/README.md @@ -30,17 +30,62 @@ This repository contains the implementation of the cross-reference metric Puzzle - (29-11-2024) Official code release -### Requirements -If you simply want to use the metric use: +### Installation + +PuzzleSim has one public entry point: + +```python +from puzzle_sim import PuzzleSim +``` + +There is no separate CUDA package. + +#### PyTorch implementation + +Install from PyPI: + ```shell pip install puzzle_sim ``` -If you want to extend it please install it locally as a package. The package requires Python 3.8 or higher. If you wish to use dinov3 backbones you must have Python 3.10 or higher and `transformers>=4.56`: +This works on CPU-only machines and on machines with PyTorch CUDA installed. If your tensors are on CUDA, PuzzleSim uses PyTorch CUDA operations automatically. + +```python +from puzzle_sim import PuzzleSim + +priors = priors.cuda() +test_image = test_image.cuda() +puzzle = PuzzleSim(reference=priors, net_type="squeeze") +similarity_map = puzzle(test_image) +``` + +#### Faster CUDA implementation + +For the faster CUDA implementation, build PuzzleSim from source. You need: +- a CUDA GPU, +- a CUDA-enabled PyTorch installation, +- the CUDA toolkit with `nvcc`, +- a compatible C++ compiler. + +Install the CUDA build of PyTorch first, using the command for your platform from the +[PyTorch installation guide](https://pytorch.org/get-started/locally/). Then build PuzzleSim: + ```shell -pip install -e . +git clone https://github.com/nihermann/PuzzleSim.git +cd PuzzleSim +pip install --upgrade pip setuptools wheel setuptools-scm +PUZZLE_SIM_BUILD_CUDA=1 pip install --no-build-isolation -v . ``` +`--no-build-isolation` is required because PyTorch's extension build uses the already-installed `torch` package. After installation, verify the compiled extension is available: + +```python +import puzzle_sim +print(puzzle_sim.get_cuda_version_info()) +``` + +The PyPI wheel does not currently include prebuilt CUDA kernels. If you do not need the faster compiled kernels, use `pip install puzzle_sim`. + ### Usage You can use the metric in your own code as follows: @@ -64,7 +109,7 @@ puzzle = PuzzleSim(reference=priors, net_type='convnext_tiny') similarity_map = puzzle(test_image, layers=range(5), weights=None, reduction='mean') # (H, W) similarity map in [0, 1] ``` -> If your GPU runs out of memory, try reducing the `stride` parameter in the forward call, this will reduce memory consumption. On the other hand, with small image dimensions the naive implementation might be faster although requiring much more memory (set `mem_save=False`). +> If your GPU runs out of memory on the PyTorch fallback path, try reducing the `stride` parameter in the forward call, this will reduce memory consumption. On the integrated CUDA path, the packed matmul backend chunks the score matrix automatically. ### Demo Please find the demo in `demo.ipynb` to see how to run the metric on some example sets. In order to run the demo, you need to pull the data from another repository. Do this by either cloning the repository using diff --git a/demo.ipynb b/demo.ipynb index 0de6951..a137ac4 100644 --- a/demo.ipynb +++ b/demo.ipynb @@ -5,14 +5,14 @@ "id": "d0b5d694ce887ef6", "metadata": {}, "source": [ - "# Puzzle Similarity Demo - PyTorch vs CUDA Comparison\n", + "# Puzzle Similarity Demo - PyTorch and Integrated CUDA Backend\n", "\n", - "This notebook demonstrates both the original PyTorch implementation and the optimized CUDA implementation of PuzzleSim, allowing for direct comparison of functionality and performance." + "This notebook demonstrates PuzzleSim with the reference PyTorch backend and the integrated automatic CUDA backend, allowing for direct comparison of functionality and performance." ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "initial_id", "metadata": { "ExecuteTime": { @@ -21,30 +21,7 @@ }, "collapsed": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Warning: CUDA extension not available. Falling back to PyTorch implementation.\n", - "šŸ§© PuzzleSim CUDA System Information\n", - "==================================================\n", - "Package Version: 0.1.0\n", - "CUDA Extension: False\n", - "PyTorch Version: 2.6.0+cu126\n", - "CUDA Available: True\n", - "CUDA Devices: 1\n", - "Device Name: NVIDIA GeForce RTX 4090\n", - "Compute Capability: 8.9\n", - "\n", - "āš ļø CUDA extension not compiled!\n", - "Run 'make build' or 'python build.py' to compile CUDA kernels\n", - "āœ… CUDA implementation available\n", - "šŸ”„ Implementation comparison: Enabled\n", - "šŸ–„ļø CUDA device: NVIDIA GeForce RTX 4090\n" - ] - } - ], + "outputs": [], "source": [ "import torch\n", "import numpy as np\n", @@ -59,23 +36,22 @@ "\n", "# Import implementations\n", "from puzzle_sim import PuzzleSim as PuzzleSimPyTorch\n", - "try:\n", - " from puzzle_sim_cuda import PuzzleSimCUDA\n", - " cuda_available = True\n", - " print(\"āœ… CUDA implementation available\")\n", - "except ImportError:\n", - " cuda_available = False\n", - " print(\"āŒ CUDA implementation not available - install puzzle_sim_cuda first\")\n", + "\n", + "cuda_available = torch.cuda.is_available()\n", + "if cuda_available:\n", + " print(\"\u2705 CUDA backend available through puzzle_sim\")\n", + "else:\n", + " print(\"\u274c CUDA backend not available - CUDA device not detected\")\n", "\n", "# Configuration\n", - "COMPARE_IMPLEMENTATIONS = cuda_available and torch.cuda.is_available()\n", - "print(f\"šŸ”„ Implementation comparison: {'Enabled' if COMPARE_IMPLEMENTATIONS else 'Disabled'}\")\n", - "print(f\"šŸ–„ļø CUDA device: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'Not available'}\")" + "COMPARE_IMPLEMENTATIONS = cuda_available\n", + "print(f\"\ud83d\udd04 Implementation comparison: {'Enabled' if COMPARE_IMPLEMENTATIONS else 'Disabled'}\")\n", + "print(f\"\ud83d\udda5\ufe0f CUDA device: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'Not available'}\")" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "c046784eac5cec31", "metadata": { "ExecuteTime": { @@ -83,26 +59,7 @@ "start_time": "2024-11-29T16:27:51.744398Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "šŸ“ Loading dataset: flowers\n", - "Loaded 2 test images and 34 priors.\n", - "šŸ”§ Initializing PyTorch implementation...\n", - " Initialization time: 0.019s\n", - "šŸš€ Initializing CUDA implementation...\n", - " āŒ CUDA extension not compiled: CUDA extension not available. Please compile the CUDA extension first.\n", - " šŸ”§ To enable CUDA acceleration:\n", - " - Run: cd puzzle_sim_cuda\n", - " - Then: make build\n", - " - Or: python build.py\n", - "\n", - "šŸ“Š Available implementations: ['PyTorch']\n" - ] - } - ], + "outputs": [], "source": [ "# Configuration\n", "dataset = \"flowers\" # select one of: \"flowers\", \"garden\", \"playroom\"\n", @@ -110,7 +67,7 @@ "resize_dims = (416, 628)\n", "\n", "# Load data\n", - "print(f\"šŸ“ Loading dataset: {dataset}\")\n", + "print(f\"\ud83d\udcc1 Loading dataset: {dataset}\")\n", "priors, test_images, test_image_names = utils.load_images(dataset, device)\n", "print(f\"Loaded {len(test_images)} test images and {len(priors)} priors.\")\n", "\n", @@ -118,9 +75,9 @@ "implementations = {}\n", "\n", "# PyTorch implementation\n", - "print(\"šŸ”§ Initializing PyTorch implementation...\")\n", + "print(\"\ud83d\udd27 Initializing PyTorch implementation...\")\n", "start_time = time.time()\n", - "puzzle_pytorch = PuzzleSimPyTorch(priors, resize=resize_dims)\n", + "puzzle_pytorch = PuzzleSimPyTorch(priors, resize=resize_dims, backend='torch')\n", "pytorch_init_time = time.time() - start_time\n", "implementations['PyTorch'] = {\n", " 'model': puzzle_pytorch,\n", @@ -129,12 +86,12 @@ "}\n", "print(f\" Initialization time: {pytorch_init_time:.3f}s\")\n", "\n", - "# CUDA implementation (if available)\n", + "# CUDA backend (if available)\n", "if COMPARE_IMPLEMENTATIONS:\n", - " print(\"šŸš€ Initializing CUDA implementation...\")\n", + " print(\"\ud83d\ude80 Initializing CUDA backend...\")\n", " try:\n", " start_time = time.time()\n", - " puzzle_cuda = PuzzleSimCUDA(priors, resize=resize_dims)\n", + " puzzle_cuda = PuzzleSimPyTorch(priors, resize=resize_dims, backend='auto')\n", " cuda_init_time = time.time() - start_time\n", " implementations['CUDA'] = {\n", " 'model': puzzle_cuda,\n", @@ -142,23 +99,23 @@ " 'device': 'CUDA'\n", " }\n", " print(f\" Initialization time: {cuda_init_time:.3f}s\")\n", - " print(f\" šŸ† CUDA speedup in init: {pytorch_init_time/cuda_init_time:.2f}x\")\n", + " print(f\" \ud83c\udfc6 CUDA speedup in init: {pytorch_init_time/cuda_init_time:.2f}x\")\n", " COMPARE_IMPLEMENTATIONS = True\n", " except RuntimeError as e:\n", - " print(f\" āŒ CUDA extension not compiled: {e}\")\n", - " print(\" šŸ”§ To enable CUDA acceleration:\")\n", - " print(\" - Run: cd puzzle_sim_cuda\")\n", - " print(\" - Then: make build\")\n", - " print(\" - Or: python build.py\")\n", + " print(f\" \u274c CUDA backend initialization failed: {e}\")\n", + " print(\" \ud83d\udd27 Optional compiled-kernel build:\")\n", + " print(\" - Run from the repository root\")\n", + " print(\" - Then: PUZZLE_SIM_BUILD_CUDA=1 pip install --no-build-isolation -v .\")\n", + " print(\" - Or use the pure PyTorch fallback without building the optional extension\")\n", " COMPARE_IMPLEMENTATIONS = False\n", " cuda_available = False\n", "\n", - "print(f\"\\nšŸ“Š Available implementations: {list(implementations.keys())}\")" + "print(f\"\\n\ud83d\udcca Available implementations: {list(implementations.keys())}\")" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "c756c214a29de5f5", "metadata": { "ExecuteTime": { @@ -166,25 +123,14 @@ "start_time": "2024-11-29T16:27:54.146782Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "utils.plot_image_tensor_row(test_images, test_image_names)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "500eeed35e8bccbe", "metadata": { "ExecuteTime": { @@ -192,28 +138,13 @@ "start_time": "2024-11-29T16:28:03.958778Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "šŸ–¼ļø Selected test image: 00007.png\n", - " Shape: torch.Size([3, 416, 628])\n", - " Device: cuda:0\n", - "\n", - "šŸ”„ Running PyTorch implementation...\n", - " ā±ļø Inference time: 12.9ms\n", - " šŸ“ Output shape: torch.Size([416, 628])\n", - " šŸ“Š Value range: [0.6773, 0.9653]\n" - ] - } - ], + "outputs": [], "source": [ "# select one of the test images\n", "selected = \"00007.png\"\n", "test_image = test_images[np.argwhere(np.array(test_image_names) == selected)[0][0]]\n", "\n", - "print(f\"šŸ–¼ļø Selected test image: {selected}\")\n", + "print(f\"\ud83d\uddbc\ufe0f Selected test image: {selected}\")\n", "print(f\" Shape: {test_image.shape}\")\n", "print(f\" Device: {test_image.device}\")\n", "\n", @@ -221,7 +152,7 @@ "results = {}\n", "\n", "for impl_name, impl_info in implementations.items():\n", - " print(f\"\\nšŸ”„ Running {impl_name} implementation...\")\n", + " print(f\"\\n\ud83d\udd04 Running {impl_name} implementation...\")\n", " model = impl_info['model']\n", " \n", " # Warm up (for fair timing)\n", @@ -246,16 +177,16 @@ " 'device': similarity_map.device\n", " }\n", " \n", - " print(f\" ā±ļø Inference time: {inference_time*1000:.1f}ms\")\n", - " print(f\" šŸ“ Output shape: {similarity_map.shape}\")\n", - " print(f\" šŸ“Š Value range: [{similarity_map.min():.4f}, {similarity_map.max():.4f}]\")\n", + " print(f\" \u23f1\ufe0f Inference time: {inference_time*1000:.1f}ms\")\n", + " print(f\" \ud83d\udcd0 Output shape: {similarity_map.shape}\")\n", + " print(f\" \ud83d\udcca Value range: [{similarity_map.min():.4f}, {similarity_map.max():.4f}]\")\n", "\n", "# Performance comparison\n", "if len(results) > 1:\n", " pytorch_time = results['PyTorch']['inference_time']\n", " cuda_time = results['CUDA']['inference_time']\n", " speedup = pytorch_time / cuda_time\n", - " print(f\"\\nšŸ† Performance Summary:\")\n", + " print(f\"\\n\ud83c\udfc6 Performance Summary:\")\n", " print(f\" PyTorch: {pytorch_time*1000:.1f}ms\")\n", " print(f\" CUDA: {cuda_time*1000:.1f}ms\")\n", " print(f\" Speedup: {speedup:.2f}x\")" @@ -263,7 +194,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "1c5293eff1cb3c5d", "metadata": { "ExecuteTime": { @@ -271,35 +202,7 @@ "start_time": "2024-11-29T16:28:05.674757Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "šŸ“Š Visualizing results from PyTorch implementation\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Visualization\n", "import matplotlib.pyplot as plt\n", @@ -309,7 +212,7 @@ " impl_name = list(results.keys())[0]\n", " similarity_map = results[impl_name]['similarity_map']\n", " \n", - " print(f\"šŸ“Š Visualizing results from {impl_name} implementation\")\n", + " print(f\"\ud83d\udcca Visualizing results from {impl_name} implementation\")\n", " utils.plot_image_tensor(test_image)\n", " utils.plot_heatmap_tensor(similarity_map)\n", " \n", @@ -360,39 +263,30 @@ " max_diff = torch.max(torch.abs(map1 - map2)).item()\n", " relative_error = max_diff / torch.max(torch.abs(map1)).item()\n", " \n", - " print(f\"\\nšŸ” Accuracy Comparison:\")\n", + " print(f\"\\n\ud83d\udd0d Accuracy Comparison:\")\n", " print(f\" Maximum absolute difference: {max_diff:.6f}\")\n", " print(f\" Relative error: {relative_error:.6f}\")\n", " \n", " if relative_error < 1e-3:\n", - " print(\" āœ… Results match within tolerance!\")\n", + " print(\" \u2705 Results match within tolerance!\")\n", " else:\n", - " print(\" āš ļø Large difference detected!\")" + " print(\" \u26a0\ufe0f Large difference detected!\")" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "609c170a", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "šŸ”§ CUDA implementation not available - skipping advanced features testing\n", - "Install puzzle_sim_cuda to enable CUDA-specific benchmarks\n" - ] - } - ], + "outputs": [], "source": [ "# Advanced Benchmarking and Configuration Testing\n", "\n", "if COMPARE_IMPLEMENTATIONS and 'CUDA' in implementations:\n", - " print(\"šŸš€ Advanced CUDA Features Testing\")\n", + " print(\"\ud83d\ude80 Advanced CUDA Features Testing\")\n", " print(\"=\" * 50)\n", " \n", - " # Test different memory modes (CUDA-specific feature)\n", + " # Test different memory modes (CUDA backend feature)\n", " memory_modes = [\n", " {'name': 'Memory-Save (stride=2)', 'mem_save': True, 'stride': 2},\n", " {'name': 'Memory-Save (stride=4)', 'mem_save': True, 'stride': 4},\n", @@ -400,7 +294,7 @@ " {'name': 'Naive Mode', 'mem_save': False, 'stride': 4},\n", " ]\n", " \n", - " print(\"\\nšŸ’¾ Testing different memory modes...\")\n", + " print(\"\\n\ud83d\udcbe Testing different memory modes...\")\n", " cuda_model = implementations['CUDA']['model']\n", " \n", " memory_results = {}\n", @@ -422,14 +316,14 @@ " 'result': result\n", " }\n", " \n", - " print(f\" ā±ļø Time: {exec_time*1000:.1f}ms\")\n", - " print(f\" šŸ§  Memory: {peak_memory:.1f}MB\")\n", + " print(f\" \u23f1\ufe0f Time: {exec_time*1000:.1f}ms\")\n", + " print(f\" \ud83e\udde0 Memory: {peak_memory:.1f}MB\")\n", " \n", " except Exception as e:\n", - " print(f\" āŒ Failed: {e}\")\n", + " print(f\" \u274c Failed: {e}\")\n", " \n", " # Test different network architectures\n", - " print(\"\\nšŸ§  Testing different network architectures...\")\n", + " print(\"\\n\ud83e\udde0 Testing different network architectures...\")\n", " net_types = ['squeeze', 'alex', 'vgg']\n", " \n", " architecture_results = {}\n", @@ -438,7 +332,7 @@ " try:\n", " # Create smaller test for speed\n", " small_resize = (128, 128)\n", - " test_puzzle = PuzzleSimCUDA(priors, net_type=net_type, resize=small_resize)\n", + " test_puzzle = PuzzleSimPyTorch(priors, net_type=net_type, resize=small_resize, backend='auto')\n", " \n", " start_time = time.perf_counter()\n", " with torch.no_grad():\n", @@ -451,60 +345,32 @@ " 'result_range': (result.min().item(), result.max().item())\n", " }\n", " \n", - " print(f\" ā±ļø Time: {exec_time*1000:.1f}ms\")\n", - " print(f\" šŸ“ Shape: {result.shape}\")\n", - " print(f\" šŸ“Š Range: [{result.min():.3f}, {result.max():.3f}]\")\n", + " print(f\" \u23f1\ufe0f Time: {exec_time*1000:.1f}ms\")\n", + " print(f\" \ud83d\udcd0 Shape: {result.shape}\")\n", + " print(f\" \ud83d\udcca Range: [{result.min():.3f}, {result.max():.3f}]\")\n", " \n", " except Exception as e:\n", - " print(f\" āŒ {net_type} failed: {e}\")\n", + " print(f\" \u274c {net_type} failed: {e}\")\n", " \n", - " print(\"\\nšŸ“Š Architecture Performance Summary:\")\n", + " print(\"\\n\ud83d\udcca Architecture Performance Summary:\")\n", " for net_type, result in architecture_results.items():\n", " print(f\" {net_type:>8}: {result['time']*1000:>6.1f}ms\")\n", "\n", "else:\n", - " print(\"šŸ”§ CUDA implementation not available - skipping advanced features testing\")\n", - " print(\"Install puzzle_sim_cuda to enable CUDA-specific benchmarks\")\n" + " print(\"\ud83d\udd27 CUDA backend not available - skipping advanced features testing\")\n", + " print(\"Use CUDA tensors to enable CUDA backend benchmarks\")\n" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "4ce1fde3", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "šŸŽÆ Performance Summary & Recommendations\n", - "============================================================\n", - "šŸ“ Single Implementation Results:\n", - " Implementation: PyTorch\n", - " Inference Time: 12.9ms\n", - " Status: āœ… Working correctly\n", - "\n", - "šŸ’” To enable CUDA acceleration and comparison:\n", - " 1. Navigate to: cd puzzle_sim_cuda\n", - " 2. Build extension: make build (or python build.py)\n", - " 3. Restart notebook and re-run cells\n", - "\n", - "šŸ”§ System Information:\n", - " PyTorch Version: 2.6.0+cu126\n", - " CUDA Available: True\n", - " CUDA Device: NVIDIA GeForce RTX 4090\n", - " CUDA Memory: 24.0GB\n", - "\n", - "āœØ Demo completed successfully!\n", - "Dataset: flowers | Test Image: 00007.png\n", - "Implementations tested: ['PyTorch']\n" - ] - } - ], + "outputs": [], "source": [ "# Summary and Recommendations\n", "\n", - "print(\"šŸŽÆ Performance Summary & Recommendations\")\n", + "print(\"\ud83c\udfaf Performance Summary & Recommendations\")\n", "print(\"=\" * 60)\n", "\n", "if COMPARE_IMPLEMENTATIONS and 'CUDA' in results and 'PyTorch' in results:\n", @@ -513,57 +379,57 @@ " cuda_time = results['CUDA']['inference_time']\n", " total_speedup = pytorch_time / cuda_time\n", " \n", - " print(f\"šŸ“ˆ Overall Performance Comparison:\")\n", + " print(f\"\ud83d\udcc8 Overall Performance Comparison:\")\n", " print(f\" PyTorch Implementation: {pytorch_time*1000:>8.1f}ms\")\n", " print(f\" CUDA Implementation: {cuda_time*1000:>8.1f}ms\") \n", - " print(f\" šŸš€ Total Speedup: {total_speedup:>8.2f}x\")\n", + " print(f\" \ud83d\ude80 Total Speedup: {total_speedup:>8.2f}x\")\n", " \n", " # Performance rating\n", " if total_speedup > 5:\n", - " print(\" šŸ† Excellent performance improvement!\")\n", - " recommendation = \"Use CUDA implementation for production workloads\"\n", + " print(\" \ud83c\udfc6 Excellent performance improvement!\")\n", + " recommendation = \"Use CUDA backend for production workloads\"\n", " elif total_speedup > 2:\n", - " print(\" āœ… Good performance improvement\")\n", - " recommendation = \"CUDA implementation recommended for most use cases\"\n", + " print(\" \u2705 Good performance improvement\")\n", + " recommendation = \"CUDA backend recommended for most use cases\"\n", " else:\n", - " print(\" āš ļø Modest improvement\")\n", + " print(\" \u26a0\ufe0f Modest improvement\")\n", " recommendation = \"Consider PyTorch for simplicity, CUDA for larger datasets\"\n", " \n", " # Memory efficiency (if tested)\n", " if 'memory_results' in locals() and memory_results:\n", - " print(f\"\\nšŸ’¾ Memory Efficiency:\")\n", + " print(f\"\\n\ud83d\udcbe Memory Efficiency:\")\n", " best_memory = min(memory_results.values(), key=lambda x: x['memory'])\n", " best_time = min(memory_results.values(), key=lambda x: x['time'])\n", " \n", " for mode_name in memory_results:\n", " result = memory_results[mode_name]\n", - " marker = \"šŸ†\" if result == best_memory else \"āš”\" if result == best_time else \" \"\n", + " marker = \"\ud83c\udfc6\" if result == best_memory else \"\u26a1\" if result == best_time else \" \"\n", " print(f\" {marker} {mode_name:<25}: {result['time']*1000:>6.1f}ms, {result['memory']:>6.1f}MB\")\n", " \n", - " print(f\"\\nšŸ’” Recommendation: {recommendation}\")\n", + " print(f\"\\n\ud83d\udca1 Recommendation: {recommendation}\")\n", " \n", "else:\n", - " print(\"šŸ“ Single Implementation Results:\")\n", + " print(\"\ud83d\udcdd Single Implementation Results:\")\n", " impl_name = list(results.keys())[0] \n", " inference_time = results[impl_name]['inference_time']\n", " print(f\" Implementation: {impl_name}\")\n", " print(f\" Inference Time: {inference_time*1000:.1f}ms\")\n", - " print(f\" Status: {'āœ… Working correctly' if len(results) > 0 else 'āŒ Issues detected'}\")\n", + " print(f\" Status: {'\u2705 Working correctly' if len(results) > 0 else '\u274c Issues detected'}\")\n", " \n", " if not cuda_available:\n", - " print(f\"\\nšŸ’” To enable CUDA acceleration and comparison:\")\n", - " print(f\" 1. Navigate to: cd puzzle_sim_cuda\")\n", - " print(f\" 2. Build extension: make build (or python build.py)\")\n", + " print(f\"\\n\ud83d\udca1 To enable CUDA acceleration and comparison:\")\n", + " print(f\" 1. Stay in the repository root\")\n", + " print(f\" 2. Build optional extension: PUZZLE_SIM_BUILD_CUDA=1 pip install --no-build-isolation -v .\")\n", " print(f\" 3. Restart notebook and re-run cells\")\n", "\n", - "print(f\"\\nšŸ”§ System Information:\")\n", + "print(f\"\\n\ud83d\udd27 System Information:\")\n", "print(f\" PyTorch Version: {torch.__version__}\")\n", "print(f\" CUDA Available: {torch.cuda.is_available()}\")\n", "if torch.cuda.is_available():\n", " print(f\" CUDA Device: {torch.cuda.get_device_name(0)}\")\n", " print(f\" CUDA Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f}GB\")\n", "\n", - "print(f\"\\nāœØ Demo completed successfully!\")\n", + "print(f\"\\n\u2728 Demo completed successfully!\")\n", "print(f\"Dataset: {dataset} | Test Image: {selected}\")\n", "print(f\"Implementations tested: {list(implementations.keys())}\")\n" ] diff --git a/puzzle_sim_cuda/README.md b/puzzle_sim_cuda/README.md deleted file mode 100644 index a8fed33..0000000 --- a/puzzle_sim_cuda/README.md +++ /dev/null @@ -1,430 +0,0 @@ -# PuzzleSim CUDA - -CUDA-accelerated implementation of PuzzleSim. - -It rewires the hot path of the reference PyTorch implementation -(`puzzle_sim.PuzzleSim`): - -* channel-wise L2 normalization and bilinear upsample are replaced by custom - CUDA kernels (2-4x and ~1-2x faster than the PyTorch ops respectively), -* the per-layer "similarity vs reference distribution + max" runs on - three back-ends selectable via a `precision=` argument: - * `"fp32"` - chunked `torch.matmul + max` over packed reference features. - Hardest to beat numerically; default when the GPU does not support - tensor cores. - * `"tf32"` (default on `sm_80+`) - a custom WMMA kernel that fuses GEMM - with the row-wise max so the full `(qHW x K)` score matrix (several GB - on the largest scenarios) never has to hit DRAM. - * `"fp16"` - same kernel, half-precision A/B fragments. -* an optional `implementation="fused"` mode (SqueezeNet only for now) that - collapses the entire pipeline - scaling-free backbone + L2 normalize + - sim_max + bilinear upsample + weighted sum - into a single C++ entrypoint - using cuDNN's fused conv+bias+ReLU op. Eliminates Python dispatch between - the eight Fire modules and the three layer taps; typically ~2x faster than - the kernel implementation on resized scenarios. - -The torchvision backbone is shared by both paths and is left untouched. - -## Requirements - -- CUDA-capable GPU, compute capability 7.0+ -- CUDA Toolkit 11.8+ -- PyTorch 1.13+ built with CUDA -- A C++ host compiler supported by your CUDA toolkit (MSVC 2017-2022 on - Windows, GCC 9-12 on Linux) - -## Build - -```bash -cd puzzle_sim_cuda -python build.py # build the extension in-place -python build.py --clean # rebuild from scratch -``` - -On Windows you must run from a "Developer Command Prompt for VS 2022" (or any -shell where `vcvars64.bat` has been executed) so the build can find `cl.exe`. - -## Usage - -The CUDA model has the same public API as `puzzle_sim.PuzzleSim`: - -```python -import torch -from puzzle_sim_cuda import PuzzleSimCUDA - -refs = torch.rand(20, 3, 256, 256, device='cuda') -img = torch.rand(1, 3, 256, 256, device='cuda') - -model = PuzzleSimCUDA(refs, net_type='squeeze', resize=(128, 128)) -similarity = model(img) # (256, 256) - -# Pick a precision explicitly: -model_tf32 = PuzzleSimCUDA(refs, precision='tf32') # default on sm_80+ -model_fp16 = PuzzleSimCUDA(refs, precision='fp16') -model_fp32 = PuzzleSimCUDA(refs, precision='fp32') # strict numerical mode - -# Fully fused pipeline (SqueezeNet only): one C++ call per forward, no Python -# dispatch between backbone layers or sim_max steps. -from puzzle_sim_cuda import PuzzleSimCUDAFused -fused = PuzzleSimCUDAFused(refs, precision='tf32') -similarity = fused(img) -``` - -For a drop-in replacement of the reference, use the `PuzzleSim` factory: - -```python -from puzzle_sim_cuda import PuzzleSim -model = PuzzleSim(refs, net_type='squeeze', use_cuda=True) - -# or the fused pipeline -model = PuzzleSim(refs, net_type='squeeze', implementation='fused') -``` - -If `use_cuda=False` or the extension is not built, the factory falls back to -the original PyTorch implementation. The `precision=` argument is forwarded -to the CUDA path. `implementation='fused'` is squeeze-only; for other -backbones it silently falls back to the kernel implementation. - -## Choosing a mode - -There are two independent knobs. Both default to the fastest *broadly safe* -option, so most users never need to touch them. - -### `implementation` - how the pipeline is orchestrated - -| value | what it does | backbones | speed | -|-------|--------------|-----------|-------| -| `"kernel"` (default) | Python drives the torchvision backbone and calls the CUDA kernels once per tapped layer. | squeeze, alex, vgg | baseline CUDA path | -| `"fused"` | One C++ call runs the *entire* SqueezeNet pipeline (backbone via cuDNN's fused conv+bias+ReLU, then the normalize / sim_max / upsample kernels) with no Python between layers. | squeeze only (auto-falls back to `"kernel"` otherwise) | **~1.1-2.5x faster than `"kernel"`** | - -### `precision` - the numeric mode of the `sim_max` contraction - -| value | kernel used | needs | error vs fp32 | -|-------|-------------|-------|---------------| -| `"tf32"` (default) | custom WMMA tensor-core kernel (16x16x8), FP32 accumulate | `sm_80+` (Ampere/Ada/Hopper) | ~1e-3 at the kernel level | -| `"fp16"` | custom WMMA tensor-core kernel (16x16x16), FP32 accumulate | `sm_70+` (Volta+) | ~5e-3 at the kernel level | -| `"fp32"` | chunked `torch.matmul + max` (cuBLAS) | any CUDA GPU | exact (reference) | - -If the GPU can't support the requested precision, or the extension isn't -built, the wrapper silently falls back to `"fp32"`. - -### Which should I pick? - -- **Just want it fast and correct?** Keep the defaults - (`implementation="kernel"`, `precision="tf32"`). -- **Running SqueezeNet (the paper default) and want the most speed?** Use - `implementation="fused"`. This is the single biggest lever - it removes the - per-layer Python/PyTorch dispatch entirely. -- **Need bit-stable, reproducible numbers** (e.g. regression baselines, - gradient checks)? Use `precision="fp32"`. It is *not* slower end-to-end (see - below) and is the most accurate. -- **Memory-constrained on a huge contraction?** `tf32`/`fp16` never - materialise the `(qHW x K)` score matrix, so they use less peak VRAM than - the chunked `fp32` path on the largest scenarios. -- **AlexNet / VGG backbone?** Only `implementation="kernel"` applies; the - factory falls back automatically. - -### Expected speedups - -Measured end-to-end on an RTX 4090 (CUDA 12.9, PyTorch 2.5.1) against the -PyTorch reference `puzzle_sim.PuzzleSim`, averaged over the real `garden` -scenarios (full table under [Benchmarks](#benchmarks)): - -| implementation | end-to-end vs PyTorch reference | -|----------------|----------------------------------| -| `kernel` | **1.4-1.6x** avg (up to ~2.1x) | -| `fused` | **2.6-2.9x** avg (up to ~4.6x) | - -Two things worth internalising: - -- **The `implementation` knob moves the needle; `precision` barely does.** - End-to-end time is dominated by the torchvision backbone, so swapping the - `sim_max` precision changes the *total* by only a few percent. `precision` - is best understood as an accuracy/VRAM knob, not a speed knob. (At the - *kernel* level, isolated from the backbone, `tf32`/`fp16` do speed up - `sim_max` by 2-9x on small/medium problems - it just gets amortised away.) -- **`fp32` is not the slow option.** cuBLAS' GEMM is exceptionally well tuned; - on the largest single contraction (`garden`, no resize) it actually beats - the custom tensor-core kernels. The custom kernels win on small/medium - problems and on memory traffic, not on the giant contraction. - -### Expected accuracy - -Max absolute error of the final similarity map (values in `[0, 1]`) versus the -strict `fp32` kernel path, measured on `garden` at `resize=(256, 256)`: - -| mode | max abs error vs fp32 | -|------|-----------------------| -| `kernel` / `fp32` | 0 (reference) | -| `kernel` / `tf32` | ~1.2e-4 | -| `kernel` / `fp16` | ~1.2e-4 | -| `fused` / `fp32` | ~1.6e-4 | -| `fused` / `fp16` / `tf32` | ~2.0e-4 | - -All modes agree with the reference to ~1e-4 on the final map. Note `tf32` and `fp16` land at nearly the -same end-to-end error: the dominant error source is the cuDNN backbone (whose -convolutions already use TF32 by default) and the bilinear resize, which swamp -the `sim_max` precision difference. The `fused` path carries a slightly larger -`fp32` error than the `kernel` path because `at::cudnn_convolution_relu` and -the standard `at::conv2d` path can pick different cuDNN convolution algorithms. - -To force bit-stable convolutions for a strict comparison, set -`torch.backends.cudnn.allow_tf32 = False`; the fused backbone features then -match torchvision to ~1e-7. - -## Use as a differentiable loss - -PuzzleSim is differentiable with respect to the **query image**, so you can use -it as a perceptual loss and optimise an image to match a reference -distribution. Both `implementation` modes support this: - -```python -import torch -from puzzle_sim_cuda import PuzzleSim - -refs = torch.rand(8, 3, 128, 128, device='cuda') # frozen reference set -model = PuzzleSim(refs, net_type='squeeze') # or implementation='fused' - -img = torch.rand(1, 3, 128, 128, device='cuda', requires_grad=True) -opt = torch.optim.Adam([img], lr=5e-2) - -for _ in range(150): - opt.zero_grad(set_to_none=True) - sim = model(img) # similarity map, higher == more similar - loss = -sim.mean() # maximise similarity == minimise this - loss.backward() # populates img.grad - opt.step() - with torch.no_grad(): - img.clamp_(0, 1) -``` - -A runnable end-to-end example (synthetic, `garden`, or your own image folder, -for either mode) lives in [`examples/loss_demo.py`](examples/loss_demo.py): - -```bash -python puzzle_sim_cuda/examples/loss_demo.py --implementation fused --steps 150 -``` - -How it works and what to expect: - -- **Only the query image gets gradients.** The backbone weights and the packed - reference features are frozen constants, exactly as in the forward metric. -- **The backward always uses an exact FP32 `sim_max`.** The tensor-core - (`tf32`/`fp16`) kernels are inference-only and have no backward, so whenever - the input requires grad the metric automatically routes the contraction - through the differentiable `matmul + max` path. The `precision` argument still - controls the *no-grad* inference path; it does not change gradient accuracy. -- **The fused mode delegates the backward.** Because the fused C++ pipeline - bypasses autograd, a grad-requiring forward transparently runs through a - kernel-mode model built from the same weights/reference. The fast, - single-call fused path is used whenever gradients are *not* required. -- **The fast inference path is untouched.** With no grad required (or under - `torch.no_grad()`) you get the exact same detached output and custom kernels - as before - the differentiable path only activates when the input carries - grad and grad is enabled. - -The gradients are verified two ways in `tests/test_grad.py`: a central -finite-difference check of the directional derivative (matches the analytic -gradient to <5%) and an Adam loop that provably reduces the loss. For a strict -`gradcheck`-style comparison, set `torch.backends.cudnn.allow_tf32 = False` so -the backbone convolutions are computed in exact FP32. - -## Tests - -```bash -# From the repo root -python -m pytest puzzle_sim_cuda/tests -v -``` - -The suite (112 tests) covers: - -- per-op correctness against an obvious PyTorch reference (normalize, pack, - sim-max, upsample) - `tests/test_kernels.py` -- end-to-end agreement with `puzzle_sim.PuzzleSim` across all backbones, - input shapes, with and without `resize` - `tests/test_puzzlesim.py` -- tensor-core precision modes vs the fp32 baseline with mode-aware tolerances - (fp32 1e-5, tf32 1e-3, fp16 5e-3) - `tests/test_tensor_cores.py` -- the fused implementation vs the kernel implementation at every precision, - plus factory dispatch and squeeze-only fallback - `tests/test_fused.py` -- differentiability of both modes: backward populates the query gradient, the - inference path stays detached, a finite-difference check of the directional - derivative, and an Adam loop that reduces the loss - `tests/test_grad.py` -- end-to-end agreement on the bundled `garden` real-image dataset - - `tests/test_real_data.py` -- edge cases: weights validation, reduction modes, reference cache, invalid - precision, etc. - -The real-data tests skip cleanly when `PuzzleSim-demo-data/samples/garden` -is not present. - -If you see pytest plugin-import failures unrelated to this package, set -`PYTEST_DISABLE_PLUGIN_AUTOLOAD=1` before running. - -## Benchmarks - -```bash -python puzzle_sim_cuda/benchmark.py # quick synthetic set -python puzzle_sim_cuda/benchmark.py --scenarios all # full synthetic sweep -python puzzle_sim_cuda/benchmark.py --scenarios real # real images (garden) -python puzzle_sim_cuda/benchmark.py --scenarios all+real # all of the above -python puzzle_sim_cuda/benchmark.py --precision all # fp32 + tf32 + fp16 side by side -python puzzle_sim_cuda/benchmark.py --implementation all # kernel + fused side by side -python puzzle_sim_cuda/benchmark.py --csv out.csv # also dump CSV -``` - -The benchmark reports, for each scenario: - -| column | meaning | -|---------------|---------------------------------------------------------------| -| `backbone_ms` | scaling + resize + torchvision backbone (shared by both) | -| `ref_total` | full PyTorch reference forward | -| `cuda_total` | full CUDA forward | -| `ref_core` | `ref_total - backbone_ms` (the part the kernels replace) | -| `cuda_core` | `cuda_total - backbone_ms` | -| `total_sp` | `ref_total / cuda_total` | -| `core_sp` | `ref_core / cuda_core` (only the kernel work) | -| `ref_MB`/`cuda_MB` | peak GPU memory | - -`>>` in the `core_sp` column means the CUDA work is below the timing noise -floor relative to the backbone (i.e. effectively free). - -Sample numbers on an RTX 4090 (CUDA 12.9, PyTorch 2.5.1), from -`--scenarios real --implementation all --precision all`. `fused` rows are -absent for alex/vgg because that path is squeeze-only: - -``` -scenario impl prec backbone ref_total cuda_total ref_core cuda_core total_sp core_sp -garden(36x628x416) kernel fp32 1.45 12.70 10.82 11.25 9.37 1.17x 1.20x -garden(36x628x416) kernel tf32 1.45 12.70 14.60 11.25 13.15 0.87x 0.86x -garden(36x628x416) kernel fp16 1.45 12.70 11.76 11.25 10.30 1.08x 1.09x -garden(36x628x416) fused fp32 1.45 12.70 10.20 11.25 8.75 1.25x 1.29x -garden(36x628x416) fused tf32 1.45 12.70 13.43 11.25 11.98 0.95x 0.94x -garden(36x628x416) fused fp16 1.45 12.70 10.79 11.25 9.33 1.18x 1.21x -garden(...,resize=256) kernel fp32 1.56 3.70 2.41 2.14 0.85 1.54x 2.52x -garden(...,resize=256) kernel tf32 1.56 3.70 2.62 2.14 1.05 1.42x 2.03x -garden(...,resize=256) kernel fp16 1.56 3.70 2.42 2.14 0.85 1.53x 2.51x -garden(...,resize=256) fused fp32 1.56 3.70 1.31 2.14 0.00 2.82x >> -garden(...,resize=256) fused tf32 1.56 3.70 1.51 2.14 0.00 2.45x >> -garden(...,resize=256) fused fp16 1.56 3.70 1.29 2.14 0.00 2.87x >> -garden(...,resize=128) kernel fp32 1.64 3.48 1.90 1.83 0.26 1.83x 7.16x -garden(...,resize=128) kernel tf32 1.64 3.48 2.06 1.83 0.41 1.69x 4.44x -garden(...,resize=128) kernel fp16 1.64 3.48 2.08 1.83 0.44 1.67x 4.21x -garden(...,resize=128) fused fp32 1.64 3.48 0.76 1.83 0.00 4.58x >> -garden(...,resize=128) fused tf32 1.64 3.48 0.81 1.83 0.00 4.30x >> -garden(...,resize=128) fused fp16 1.64 3.48 0.84 1.83 0.00 4.16x >> -garden-alex(resize=256) kernel fp32 0.49 1.59 0.75 1.10 0.26 2.12x 4.18x -garden-alex(resize=256) kernel tf32 0.49 1.59 0.97 1.10 0.48 1.64x 2.29x -garden-alex(resize=256) kernel fp16 0.49 1.59 0.95 1.10 0.46 1.68x 2.40x -garden-vgg(resize=128) kernel fp32 1.00 3.35 2.34 2.35 1.35 1.43x 1.74x -garden-vgg(resize=128) kernel tf32 1.00 3.35 2.93 2.35 1.93 1.14x 1.22x -garden-vgg(resize=128) kernel fp16 1.00 3.35 2.12 2.35 1.12 1.58x 2.10x -``` - -Average end-to-end speedup vs the PyTorch reference over the real scenarios: - -| implementation | fp32 | tf32 | fp16 | -|----------------|------|------|------| -| `kernel` | 1.62x (max 2.12x) | 1.35x (max 1.69x) | 1.51x (max 1.68x) | -| `fused` | 2.88x (max 4.58x) | 2.56x (max 4.30x) | 2.74x (max 4.16x) | - -Head-to-head, `fused` is **1.06-2.54x faster than `kernel`** at the same -precision (avg 1.80x), and uses noticeably less peak VRAM (e.g. 3.0 GB vs -4.0-4.4 GB on `garden` with no resize) because it keeps no PyTorch -intermediates between layers. - -Notes: - -- On Windows the GPU is shared with the display (WDDM), so per-sample times - jitter heavily (5-15% run to run). The benchmark uses CUDA events and - reports the best of N runs - the only signal that is stable. -- The largest scenario (`garden(36x628x416)`, no resize) is bound by the - similarity contraction itself - 256 channels x 36 references x - 628x416 ~ 150k reference pixels. cuBLAS' chunked FP32 path is genuinely - hard to beat there (vendor library, two decades of tuning), and the - tensor-core kernels pay a small DRAM round-trip cost for their per-block - partial maxes; on this one scenario `tf32`/`fp16` actually lag `fp32`. The - custom kernels win on the smaller / resized scenarios and on peak memory. -- End-to-end, the `precision` choice is nearly speed-neutral because the - shared torchvision backbone dominates the total. The big lever is - `implementation`: `fused` removes all per-layer Python dispatch. -- The TF32/FP16 path lights up tensor cores via `nvcuda::wmma` (16x16x8 for - TF32, 16x16x16 for FP16). When the requested precision is not supported - by the device (e.g. TF32 below `sm_80`), the wrapper silently falls back - to `fp32`. - -## Layout - -``` -puzzle_sim_cuda/ -ā”œā”€ā”€ src/ -ā”‚ ā”œā”€ā”€ kernels.cu # CUDA kernels (normalize, sim_max tensor-core, upsample) -ā”‚ ā”œā”€ā”€ puzzle_sim_cuda.cpp # PyTorch bindings + FusedSqueezeNet registration -ā”‚ ā””ā”€ā”€ fused_inference.cpp # FusedSqueezeNet: whole pipeline in one C++ call -ā”œā”€ā”€ puzzle_sim_cuda.py # kernel-path wrapper (PuzzleSimCUDA) + PuzzleSim factory -ā”œā”€ā”€ puzzle_sim_cuda_fused.py # fused-path wrapper (PuzzleSimCUDAFused) -ā”œā”€ā”€ __init__.py # package entry point -ā”œā”€ā”€ setup.py # setuptools build config -ā”œā”€ā”€ build.py # convenience wrapper around `python setup.py build_ext` -ā”œā”€ā”€ benchmark.py # head-to-head benchmark against the PyTorch reference -ā”œā”€ā”€ examples/ -ā”‚ ā””ā”€ā”€ loss_demo.py # optimise an image with PuzzleSim as a differentiable loss -ā”œā”€ā”€ requirements.txt # runtime + dev dependencies -ā”œā”€ā”€ tests/ # pytest correctness suite (incl. test_grad.py) -ā””ā”€ā”€ README.md -``` - -## What's inside - -Three CUDA kernels, a packing helper, and the fused C++ pipeline: - -1. `normalize_features` - channel-wise L2 normalize, one thread per spatial - location. Replaces - `feat / sqrt(eps + feat.pow(2).sum(dim=1, keepdim=True))`. Roughly 2-4x - faster than the PyTorch chain because the entire pipeline (squared sum, - `rsqrtf`, scale) is fused into a single kernel. - -2. `bilinear_upsample` - 2D bilinear upsample of a `(H, W)` similarity map. - Replaces the `nn.Upsample` call at the end of the forward. Faster than - `F.interpolate` for small inputs because there is no python-side dispatch - and the kernel is purpose-built for the 2D case. - -3. `pack_reference` - one-time layout transform. Reference features come - in as `(N, C, H, W)`; the contraction wants `(C, N*H*W)`. Doing this - once at construction and caching the result removes a per-call - `permute + reshape + contiguous`. - -4. `sim_max_tf32` / `sim_max_fp16` - WMMA tensor-core kernels that fuse - the `(Q.T @ R).max(dim=1)` contraction into a single pipeline. Each - block computes the max over a `(TILE_M=64) x (TILE_N=128)` sub-tile of - the score matrix using `wmma::mma_sync` (16x16x8 TF32 or 16x16x16 - FP16) accumulating in FP32 fragments, then writes a per-tile partial - max into a small staging buffer. A second small kernel reduces the - partials per query row. Net effect: the `(qHW x K)` score matrix is - never materialised in DRAM. The full FP32 fall-back stays available - via `precision="fp32"` and is still the most accurate path; it is also - often the fastest on the very largest scenarios because cuBLAS' GEMM - is exceptionally well tuned there. - -5. `FusedSqueezeNet` (C++ class in `src/fused_inference.cpp`) - holds - the SqueezeNet1.1 weights pre-extracted from torchvision and runs the - entire metric in a single C++ call. Convolutions go through - `at::cudnn_convolution_relu`, the C++ binding to cuDNN's fused - `cudnnConvolutionBiasActivationForward` (conv + bias + ReLU in one - shot). Max-pool uses `at::max_pool2d`. Once the backbone has produced - the three layer taps, the same `normalize_features` / `sim_max_*` / - `bilinear_upsample` kernels listed above are invoked back-to-back - - no Python on the per-layer hot path. Exposed in Python via - `PuzzleSimCUDAFused`. Squeeze-only for now; the same scaffolding will - carry AlexNet and VGG. - -The chunked `precision="fp32"` similarity contraction uses Python-side -`torch.matmul + max`. cuBLAS' tiled, register-blocked GEMM is hard to beat -on this workload; chunking along `K` keeps the transient score matrix -bounded - by default the per-step tile is sized to stay under ~256 MB -regardless of the reference count. - -Everything runs on PyTorch's current CUDA stream. - -## License - -Apache 2.0. Same as the parent project. diff --git a/puzzle_sim_cuda/__init__.py b/puzzle_sim_cuda/__init__.py deleted file mode 100644 index 7026bf4..0000000 --- a/puzzle_sim_cuda/__init__.py +++ /dev/null @@ -1,30 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -"""CUDA-accelerated PuzzleSim metric.""" - -from .puzzle_sim_cuda import CUDA_EXT_AVAILABLE, PuzzleSim, PuzzleSimCUDA -from .puzzle_sim_cuda_fused import PuzzleSimCUDAFused - -__version__ = "0.2.0" -__all__ = [ - "PuzzleSim", - "PuzzleSimCUDA", - "PuzzleSimCUDAFused", - "CUDA_EXT_AVAILABLE", -] - - -def get_version_info() -> dict: - """Return a dict with package, torch and CUDA version info.""" - import torch - - info = { - "package_version": __version__, - "cuda_extension_available": CUDA_EXT_AVAILABLE, - "torch_version": torch.__version__, - "cuda_available": torch.cuda.is_available(), - "cuda_device_count": torch.cuda.device_count() if torch.cuda.is_available() else 0, - } - if torch.cuda.is_available(): - info["cuda_device_name"] = torch.cuda.get_device_name(0) - info["cuda_capability"] = torch.cuda.get_device_capability(0) - return info diff --git a/puzzle_sim_cuda/benchmark.py b/puzzle_sim_cuda/benchmark.py deleted file mode 100644 index 2d884ca..0000000 --- a/puzzle_sim_cuda/benchmark.py +++ /dev/null @@ -1,548 +0,0 @@ -#!/usr/bin/env python3 -# SPDX-License-Identifier: Apache-2.0 -"""Benchmark suite for PuzzleSim CUDA against the PyTorch reference. - -The script reports: - -* ``backbone_only``: the cost of the torchvision backbone + scaling. This is - shared by both implementations and acts as an effective floor on total time. -* ``ref total`` / ``cuda total``: end-to-end forward pass on the reference and - CUDA implementations, including the backbone. -* ``ref core`` / ``cuda core``: end-to-end minus the backbone cost - this is - the portion that the CUDA kernels are actually replacing. -* ``total speedup``: ref/cuda for end-to-end time. -* ``core speedup``: ref-core/cuda-core - the meaningful number for the kernel - work itself. - -Run with ``python benchmark.py``. Use ``--scenarios all`` for a larger sweep, -``--csv path.csv`` to dump results, ``--reps N`` to change timing samples. -""" - -from __future__ import annotations - -import argparse -import csv -import os -import sys -import time -from dataclasses import dataclass, asdict -from typing import Callable, List, Optional, Tuple - -import torch - -# Allow running this script from anywhere. We need: -# * ``_REPO_ROOT`` on sys.path so ``import puzzle_sim`` (reference impl) -# resolves AND ``import puzzle_sim_cuda`` resolves to the *package* -# (not the inner module of the same name); -# * ``_PKG_DIR`` on sys.path so the ``puzzle_sim_cuda_ext`` C++ extension -# - which lives inside the package directory - is importable. -# Order matters: _REPO_ROOT must come first so the package wins. We insert -# _PKG_DIR first then _REPO_ROOT so the final layout is [_REPO_ROOT, _PKG_DIR, ...]. -_REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) -_PKG_DIR = os.path.dirname(os.path.abspath(__file__)) -for p in (_PKG_DIR, _REPO_ROOT): - if p not in sys.path: - sys.path.insert(0, p) - - -def _cuda_sync() -> None: - if torch.cuda.is_available(): - torch.cuda.synchronize() - - -def _bench(fn: Callable[[], object], reps: int, warmup: int) -> Tuple[float, float]: - """Return (best seconds, peak GPU MB) over ``reps`` runs. - - Uses ``torch.cuda.Event`` for device-side timing. We report the best - (minimum) sample because Windows WDDM and background GPU work routinely - add 100ms-class delays on top of the actual kernel work; the median is - not a stable signal of what the kernels themselves cost. The minimum - approximates the no-contention runtime - which is the meaningful number - when comparing two implementations. - """ - for _ in range(warmup): - fn() - _cuda_sync() - if torch.cuda.is_available(): - torch.cuda.reset_peak_memory_stats() - - samples: List[float] = [] - if torch.cuda.is_available(): - start = torch.cuda.Event(enable_timing=True) - end = torch.cuda.Event(enable_timing=True) - for _ in range(reps): - start.record() - fn() - end.record() - end.synchronize() - samples.append(start.elapsed_time(end) / 1000.0) - else: - for _ in range(reps): - t0 = time.perf_counter() - fn() - samples.append(time.perf_counter() - t0) - - best = min(samples) - peak_mb = ( - torch.cuda.max_memory_allocated() / 1024 / 1024 - if torch.cuda.is_available() else 0.0 - ) - return best, peak_mb - - -@dataclass -class ScenarioResult: - scenario: str - precision: str - implementation: str - backbone_ms: float - ref_total_ms: float - cuda_total_ms: float - ref_core_ms: float - cuda_core_ms: float - total_speedup: float - core_speedup: float - ref_peak_mb: float - cuda_peak_mb: float - - def as_row(self) -> List[str]: - # When cuda_core is well below the measurement noise floor (i.e. the - # CUDA work is essentially free compared to the backbone) the ratio is - # not meaningful - report '>=N' as a lower bound instead. - if self.cuda_core_ms < 0.05: - core_cell = f" >> " - else: - core_cell = f"{self.core_speedup:5.2f}x" - return [ - self.scenario, - self.implementation, - self.precision, - f"{self.backbone_ms:7.2f}", - f"{self.ref_total_ms:7.2f}", - f"{self.cuda_total_ms:7.2f}", - f"{self.ref_core_ms:7.2f}", - f"{self.cuda_core_ms:7.2f}", - f"{self.total_speedup:5.2f}x", - core_cell, - f"{self.ref_peak_mb:6.0f}", - f"{self.cuda_peak_mb:6.0f}", - ] - - -def _measure_backbone( - model, - img: torch.Tensor, - resize: Optional[Tuple[int, int]], - reps: int, - warmup: int, -) -> float: - """Time the scaling + (optional) resize + backbone forward. - - Both implementations share this code path, so this measurement is - representative of the per-call backbone cost in the full forward. - The caller is expected to pass a model whose backbone has already been - exercised at least once (cuDNN tunes its kernels on first input shape). - """ - from puzzle_sim import _resize_tensor as torch_resize - - def go(): - with torch.no_grad(): - x = 2 * img - 1 - x = model.scaling_layer(x) - if resize is not None: - x = torch_resize(x, size=resize, align_corners=True) - model.net.forward(x) - t, _ = _bench(go, reps=reps, warmup=warmup) - return t * 1000 - - -def _load_dataset(name: str, device: str) -> Optional[Tuple[torch.Tensor, torch.Tensor]]: - """Load a sample dataset from ``PuzzleSim-demo-data/samples/``. - - Returns ``(priors, tests)`` or ``None`` if the data is unavailable. - """ - from pathlib import Path - base = Path(_REPO_ROOT) / "PuzzleSim-demo-data" / "samples" / name - if not (base / "prior").is_dir() or not (base / "test").is_dir(): - return None - from PIL import Image - import torchvision.transforms.functional as TF - - def _load_dir(p: "Path"): - names = sorted(x for x in p.iterdir() if x.suffix.lower() == ".png") - imgs = [TF.to_tensor(Image.open(x).convert("RGB")).unsqueeze(0) for x in names] - return torch.cat(imgs, dim=0) - - priors = _load_dir(base / "prior").to(device) - tests = _load_dir(base / "test").to(device) - return priors, tests - - -def run_scenario( - name: str, - num_refs: int, - ref_hw: Tuple[int, int], - test_hw: Tuple[int, int], - net_type: str = "squeeze", - resize: Optional[Tuple[int, int]] = None, - reps: int = 20, - warmup: int = 3, - precisions: Tuple[str, ...] = ("tf32",), - implementations: Tuple[str, ...] = ("kernel",), -) -> List[ScenarioResult]: - refs = torch.rand(num_refs, 3, *ref_hw, device="cuda") - img = torch.rand(1, 3, *test_hw, device="cuda") - - return _run_pair( - name, refs, img, net_type=net_type, resize=resize, - reps=reps, warmup=warmup, precisions=precisions, - implementations=implementations, - ) - - -def _make_cuda_model(impl: str, refs: torch.Tensor, net_type: str, - resize: Optional[Tuple[int, int]], precision: str): - """Construct a CUDA model for the given implementation choice. - - ``impl='fused'`` only supports the SqueezeNet backbone today; for any - other ``net_type`` the call returns ``None`` so the caller can skip the - fused row. - """ - from puzzle_sim_cuda import PuzzleSimCUDA, PuzzleSimCUDAFused - - if impl == "kernel": - return PuzzleSimCUDA(refs, net_type=net_type, resize=resize, precision=precision) - if impl == "fused": - if net_type != "squeeze": - return None - return PuzzleSimCUDAFused(refs, resize=resize, precision=precision) - raise ValueError(f"Unknown implementation: {impl!r}") - - -def _run_pair( - name: str, - refs: torch.Tensor, - img: torch.Tensor, - net_type: str, - resize: Optional[Tuple[int, int]], - reps: int, - warmup: int, - precisions: Tuple[str, ...], - implementations: Tuple[str, ...] = ("kernel",), -) -> List[ScenarioResult]: - """Benchmark a reference/CUDA model pair across implementations + precisions. - - Reference is timed once (it does not have a precision/implementation - setting). For each (implementation, precision) pair, the CUDA model is - built fresh, warmed, then timed. The backbone measurement is shared - across all CUDA configurations. - """ - from puzzle_sim import PuzzleSim as RefPuzzleSim - from puzzle_sim_cuda import PuzzleSimCUDA - - ref_model = RefPuzzleSim(refs, net_type=net_type, resize=resize).to(refs.device).eval() - - # Warm and time the backbone once (same architecture across precisions). - warm_cuda = PuzzleSimCUDA(refs, net_type=net_type, resize=resize, precision="fp32") - with torch.no_grad(): - for _ in range(warmup): - ref_model(img) - warm_cuda(img) - _cuda_sync() - - backbone_ms = _measure_backbone( - warm_cuda, img, resize=resize, reps=reps, warmup=2, - ) - - def run_ref(): - with torch.no_grad(): - ref_model(img) - ref_t, ref_mem = _bench(run_ref, reps=reps, warmup=2) - ref_ms = ref_t * 1000 - - out: List[ScenarioResult] = [] - for impl in implementations: - for precision in precisions: - cuda_model = _make_cuda_model(impl, refs, net_type, resize, precision) - if cuda_model is None: - # fused requested but unsupported for this net_type - skip silently. - continue - with torch.no_grad(): - for _ in range(warmup): - cuda_model(img) - _cuda_sync() - - def run_cuda(): - with torch.no_grad(): - cuda_model(img) - cuda_t, cuda_mem = _bench(run_cuda, reps=reps, warmup=2) - cuda_ms = cuda_t * 1000 - ref_core = max(0.0, ref_ms - backbone_ms) - cuda_core = max(0.0, cuda_ms - backbone_ms) - out.append(ScenarioResult( - scenario=name, - precision=precision, - implementation=impl, - backbone_ms=backbone_ms, - ref_total_ms=ref_ms, - cuda_total_ms=cuda_ms, - ref_core_ms=ref_core, - cuda_core_ms=cuda_core, - total_speedup=ref_ms / max(cuda_ms, 1e-6), - core_speedup=ref_core / max(cuda_core, 1e-6), - ref_peak_mb=ref_mem, - cuda_peak_mb=cuda_mem, - )) - return out - - -QUICK_SCENARIOS = [ - dict(name="5x64", num_refs=5, ref_hw=(64, 64), test_hw=(64, 64)), - dict(name="10x128", num_refs=10, ref_hw=(128, 128), test_hw=(128, 128)), - dict(name="20x256(resize=128)", num_refs=20, ref_hw=(256, 256), test_hw=(256, 256), resize=(128, 128)), -] - - -FULL_SCENARIOS = QUICK_SCENARIOS + [ - dict(name="50x128", num_refs=50, ref_hw=(128, 128), test_hw=(128, 128)), - dict(name="50x256(resize=128)", num_refs=50, ref_hw=(256, 256), test_hw=(256, 256), resize=(128, 128)), - dict(name="10x256-alex", num_refs=10, ref_hw=(256, 256), test_hw=(256, 256), resize=(128, 128), net_type="alex"), - dict(name="10x256-vgg", num_refs=10, ref_hw=(256, 256), test_hw=(256, 256), resize=(128, 128), net_type="vgg"), -] - - -# Real-data scenarios run on the named demo dataset. They are skipped at -# runtime if the data is not present. -REAL_SCENARIOS = [ - dict(name="garden(36x628x416)", dataset="garden", resize=None, net_type="squeeze"), - dict(name="garden(36x628x416,resize=256)", dataset="garden", resize=(256, 256), net_type="squeeze"), - dict(name="garden(36x628x416,resize=128)", dataset="garden", resize=(128, 128), net_type="squeeze"), - dict(name="garden-alex(resize=256)", dataset="garden", resize=(256, 256), net_type="alex"), - dict(name="garden-vgg(resize=128)", dataset="garden", resize=(128, 128), net_type="vgg"), -] - - -_COL_WIDTHS = [34, 7, 6, 11, 9, 10, 8, 9, 8, 7, 7, 7] - - -def _print_header() -> None: - headers = [ - "scenario", "impl", "prec", "backbone_ms", "ref_total", "cuda_total", - "ref_core", "cuda_core", "total_sp", "core_sp", - "ref_MB", "cuda_MB", - ] - print(" ".join(h.ljust(w) for h, w in zip(headers, _COL_WIDTHS))) - print("-" * (sum(_COL_WIDTHS) + len(_COL_WIDTHS) * 2)) - - -def _print_result(r: ScenarioResult) -> None: - cells = r.as_row() - print(" ".join(c.ljust(w) for c, w in zip(cells, _COL_WIDTHS))) - - -def _run_real_scenario( - name: str, - dataset: str, - resize: Optional[Tuple[int, int]], - net_type: str, - reps: int, - warmup: int, - precisions: Tuple[str, ...], - implementations: Tuple[str, ...] = ("kernel",), -) -> Optional[List[ScenarioResult]]: - """Run a benchmark scenario on a real demo dataset. - - Returns ``None`` if the dataset is unavailable so the caller can skip. - """ - data = _load_dataset(dataset, "cuda") - if data is None: - return None - refs, tests = data - img = tests[0:1] - return _run_pair( - name, refs, img, net_type=net_type, resize=resize, - reps=reps, warmup=warmup, precisions=precisions, - implementations=implementations, - ) - - -def _parse_precisions(spec: str) -> Tuple[str, ...]: - """Parse a comma-separated precision spec. - - ``"all"`` expands to ``("fp32", "tf32", "fp16")``. Individual items must be - one of the supported precisions. - """ - if spec == "all": - return ("fp32", "tf32", "fp16") - valid = {"fp32", "tf32", "fp16"} - out: List[str] = [] - for tok in spec.split(","): - tok = tok.strip() - if tok not in valid: - raise SystemExit( - f"--precision: {tok!r} is not one of {sorted(valid)} (or 'all')" - ) - out.append(tok) - return tuple(out) - - -def _parse_implementations(spec: str) -> Tuple[str, ...]: - if spec == "all": - return ("kernel", "fused") - valid = {"kernel", "fused"} - out: List[str] = [] - for tok in spec.split(","): - tok = tok.strip() - if tok not in valid: - raise SystemExit( - f"--implementation: {tok!r} is not one of {sorted(valid)} (or 'all')" - ) - out.append(tok) - return tuple(out) - - -def main() -> int: - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument( - "--scenarios", - choices=["quick", "all", "real", "all+real"], - default="quick", - help=( - "Which scenario set to run. 'quick' / 'all' use synthetic random " - "tensors; 'real' uses the demo datasets (garden); 'all+real' is " - "the union." - ), - ) - parser.add_argument( - "--precision", - type=str, - default="tf32", - help=( - "Comma-separated precisions to benchmark, or 'all' for fp32,tf32,fp16. " - "Each scenario is emitted as one row per precision." - ), - ) - parser.add_argument( - "--implementation", - type=str, - default="kernel", - help=( - "Comma-separated implementations to benchmark, or 'all' for " - "kernel,fused. 'fused' is only valid for net_type='squeeze' and " - "is silently skipped for other backbones." - ), - ) - parser.add_argument("--reps", type=int, default=15) - parser.add_argument("--warmup", type=int, default=5) - parser.add_argument("--csv", type=str, default=None, - help="Optional path to write the results table to.") - args = parser.parse_args() - - if not torch.cuda.is_available(): - print("CUDA not available.") - return 1 - - precisions = _parse_precisions(args.precision) - implementations = _parse_implementations(args.implementation) - - print(f"GPU: {torch.cuda.get_device_name(0)}") - print(f"CUDA capability: {torch.cuda.get_device_capability(0)}") - print(f"PyTorch: {torch.__version__}") - print(f"precisions: {', '.join(precisions)}") - print(f"implementations: {', '.join(implementations)}") - print() - - synthetic = [] - real = [] - if args.scenarios in ("quick",): - synthetic = QUICK_SCENARIOS - elif args.scenarios in ("all",): - synthetic = FULL_SCENARIOS - elif args.scenarios == "real": - real = REAL_SCENARIOS - elif args.scenarios == "all+real": - synthetic = FULL_SCENARIOS - real = REAL_SCENARIOS - - _print_header() - results: List[ScenarioResult] = [] - for sc in synthetic: - try: - rs = run_scenario(reps=args.reps, warmup=args.warmup, - precisions=precisions, implementations=implementations, - **sc) - except Exception as e: # noqa: BLE001 - want to keep going on per-scenario errors - print(f"{sc['name']:22s} FAILED: {e}") - continue - for r in rs: - results.append(r) - _print_result(r) - for sc in real: - try: - rs = _run_real_scenario(reps=args.reps, warmup=args.warmup, - precisions=precisions, implementations=implementations, - **sc) - except Exception as e: # noqa: BLE001 - print(f"{sc['name']:22s} FAILED: {e}") - continue - if rs is None: - print(f"{sc['name']:22s} SKIPPED (dataset {sc['dataset']!r} not available)") - continue - for r in rs: - results.append(r) - _print_result(r) - - if results: - # Group summary by (implementation, precision). - for impl in implementations: - for precision in precisions: - subset = [r for r in results - if r.precision == precision and r.implementation == impl] - if not subset: - continue - avg_total = sum(r.total_speedup for r in subset) / len(subset) - max_total = max(r.total_speedup for r in subset) - meaningful_core = [r for r in subset if r.cuda_core_ms >= 0.05] - tag = f"[{impl}/{precision}]" - print() - print(f"{tag} avg total speedup: {avg_total:.2f}x (max {max_total:.2f}x)") - if meaningful_core: - avg_core = sum(r.core_speedup for r in meaningful_core) / len(meaningful_core) - max_core = max(r.core_speedup for r in meaningful_core) - print( - f"{tag} avg core speedup: {avg_core:.2f}x (max {max_core:.2f}x, " - f"over {len(meaningful_core)}/{len(subset)} scenarios where cuda_core > 0.05ms)" - ) - - # Direct kernel vs fused comparison (only where both are present). - if "kernel" in implementations and "fused" in implementations: - print() - print("kernel vs fused (same precision, same scenario):") - by_key: dict[Tuple[str, str], dict[str, ScenarioResult]] = {} - for r in results: - by_key.setdefault((r.scenario, r.precision), {})[r.implementation] = r - ratios: List[float] = [] - for (scenario, precision), per in sorted(by_key.items()): - if "kernel" in per and "fused" in per: - k = per["kernel"].cuda_total_ms - f = per["fused"].cuda_total_ms - ratio = k / max(f, 1e-6) - ratios.append(ratio) - print(f" {scenario:38s} {precision:5s} kernel={k:6.2f}ms fused={f:6.2f}ms fused_sp={ratio:5.2f}x") - if ratios: - avg = sum(ratios) / len(ratios) - print(f" fused vs kernel: avg {avg:.2f}x, max {max(ratios):.2f}x, min {min(ratios):.2f}x") - - if args.csv: - with open(args.csv, "w", newline="") as f: - writer = csv.DictWriter(f, fieldnames=list(asdict(results[0]).keys()) if results else []) - writer.writeheader() - for r in results: - writer.writerow(asdict(r)) - print(f"\nWrote {args.csv}") - - return 0 - - -if __name__ == "__main__": - sys.exit(main()) diff --git a/puzzle_sim_cuda/build.py b/puzzle_sim_cuda/build.py deleted file mode 100644 index c6ac5b5..0000000 --- a/puzzle_sim_cuda/build.py +++ /dev/null @@ -1,54 +0,0 @@ -#!/usr/bin/env python3 -# SPDX-License-Identifier: Apache-2.0 -"""Convenience entry point for building the CUDA extension. - -This is a thin wrapper around ``python setup.py build_ext --inplace`` that -keeps the working directory pinned to the location of ``setup.py``. -""" - -import argparse -import os -import shutil -import subprocess -import sys - - -def _run(cmd: list[str]) -> int: - print("$", " ".join(cmd), flush=True) - return subprocess.call(cmd) - - -def main() -> int: - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--clean", action="store_true", - help="Remove build artifacts before building") - parser.add_argument("--verbose", action="store_true", - help="Verbose build output") - args = parser.parse_args() - - here = os.path.dirname(os.path.abspath(__file__)) - os.chdir(here) - - if args.clean: - for d in ("build", "dist"): - if os.path.exists(d): - shutil.rmtree(d) - print(f"removed {d}/") - - cmd = [sys.executable, "setup.py", "build_ext", "--inplace"] - if args.verbose: - cmd.append("--verbose") - rc = _run(cmd) - if rc != 0: - print("Build failed.", file=sys.stderr) - return rc - - print("\nBuild complete. Quick sanity check:") - rc = _run([sys.executable, "-c", - "import torch, puzzle_sim_cuda_ext as e; " - "print('loaded:', sorted([s for s in dir(e) if not s.startswith('_')]))"]) - return rc - - -if __name__ == "__main__": - sys.exit(main()) diff --git a/puzzle_sim_cuda/examples/loss_demo.py b/puzzle_sim_cuda/examples/loss_demo.py deleted file mode 100644 index 9bbe74c..0000000 --- a/puzzle_sim_cuda/examples/loss_demo.py +++ /dev/null @@ -1,174 +0,0 @@ -#!/usr/bin/env python3 -# SPDX-License-Identifier: Apache-2.0 -"""Use PuzzleSim as a differentiable perceptual loss. - -This optimises a *learnable image* so that its PuzzleSim similarity against a -reference distribution increases. The backbone weights and the reference are -frozen; gradients flow only to the image. It works with both the kernel and the -fused implementation (the fused model delegates the backward to an exact-FP32 -kernel path under the hood). - -Examples --------- -Synthetic reference, kernel mode:: - - python loss_demo.py --steps 150 - -Fused mode against the garden demo set (if checked out):: - - python loss_demo.py --implementation fused --reference garden --steps 150 - -Optimise toward a folder of PNGs and save the result:: - - python loss_demo.py --reference path/to/imgs --out optimized.png -""" - -from __future__ import annotations - -import argparse -import os -import sys -from typing import Optional - -import torch - -# [_REPO_ROOT, _PKG_DIR] so ``puzzle_sim`` + the ``puzzle_sim_cuda`` *package* -# resolve, and the co-located C++ extension is importable. See benchmark.py. -_REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) -_PKG_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) -for p in (_PKG_DIR, _REPO_ROOT): - if p not in sys.path: - sys.path.insert(0, p) - - -def _synthetic_reference(n: int, size: int, device: str) -> torch.Tensor: - """A few smooth low-frequency colour fields - cheap, structured targets.""" - torch.manual_seed(1234) - ys = torch.linspace(0, 1, size, device=device) - xs = torch.linspace(0, 1, size, device=device) - gy, gx = torch.meshgrid(ys, xs, indexing="ij") - refs = [] - for i in range(n): - fx, fy = 1.0 + 2.0 * i, 1.5 + 1.5 * i - r = 0.5 + 0.5 * torch.sin(2 * torch.pi * (fx * gx + 0.1 * i)) - g = 0.5 + 0.5 * torch.sin(2 * torch.pi * (fy * gy + 0.2 * i)) - b = 0.5 + 0.5 * torch.cos(2 * torch.pi * (fx * gx + fy * gy)) - refs.append(torch.stack([r, g, b], dim=0)) - return torch.stack(refs, dim=0).clamp(0, 1) - - -def _load_image_folder(path: str, size: int, device: str) -> Optional[torch.Tensor]: - try: - from PIL import Image - import torchvision.transforms.functional as TF - except ImportError: - print("[warn] PIL/torchvision not available; cannot load images.") - return None - exts = {".png", ".jpg", ".jpeg", ".bmp"} - files = sorted(f for f in os.listdir(path) if os.path.splitext(f)[1].lower() in exts) - if not files: - return None - imgs = [] - for f in files: - im = Image.open(os.path.join(path, f)).convert("RGB").resize((size, size)) - imgs.append(TF.to_tensor(im)) - return torch.stack(imgs, dim=0).to(device) - - -def _resolve_reference(name: str, n: int, size: int, device: str) -> torch.Tensor: - if name == "synthetic": - return _synthetic_reference(n, size, device) - if name == "garden": - garden = os.path.join(_REPO_ROOT, "PuzzleSim-demo-data", "samples", "garden", "prior") - loaded = _load_image_folder(garden, size, device) if os.path.isdir(garden) else None - if loaded is None: - print("[warn] garden demo data not found; using synthetic reference.") - return _synthetic_reference(n, size, device) - return loaded - loaded = _load_image_folder(name, size, device) - if loaded is None: - raise SystemExit(f"No usable images found at {name!r}") - return loaded - - -def _build_model(implementation: str, reference: torch.Tensor, precision: str): - from puzzle_sim_cuda import PuzzleSim - - return PuzzleSim( - reference, - net_type="squeeze", - implementation=implementation, - precision=precision, - ) - - -def _save_image(img: torch.Tensor, path: str) -> None: - try: - import torchvision.utils as vutils - except ImportError: - print(f"[warn] torchvision not available; cannot save {path}.") - return - vutils.save_image(img.clamp(0, 1), path) - print(f"saved {path}") - - -def main() -> None: - parser = argparse.ArgumentParser(description=__doc__, - formatter_class=argparse.RawDescriptionHelpFormatter) - parser.add_argument("--implementation", choices=["kernel", "fused"], default="kernel") - parser.add_argument("--precision", choices=["fp32", "tf32", "fp16"], default="tf32", - help="Inference precision. The backward always uses exact FP32.") - parser.add_argument("--reference", default="synthetic", - help="'synthetic', 'garden', or a folder of images.") - parser.add_argument("--num-refs", type=int, default=4, help="Synthetic reference count.") - parser.add_argument("--size", type=int, default=128) - parser.add_argument("--steps", type=int, default=150) - parser.add_argument("--lr", type=float, default=5e-2) - parser.add_argument("--layers", type=int, nargs="+", default=[2, 3, 4]) - parser.add_argument("--out", default=None, help="Optional path to save the optimised image.") - parser.add_argument("--device", default="cuda") - args = parser.parse_args() - - if args.device == "cuda" and not torch.cuda.is_available(): - raise SystemExit("CUDA is not available; pass --device cpu (kernel mode only).") - - reference = _resolve_reference(args.reference, args.num_refs, args.size, args.device) - print(f"reference: {tuple(reference.shape)} on {reference.device}") - - model = _build_model(args.implementation, reference, args.precision) - - img = torch.rand(1, 3, args.size, args.size, device=args.device, requires_grad=True) - if args.out: - _save_image(img.detach()[0], args.out.replace(".", "_init.", 1)) - - opt = torch.optim.Adam([img], lr=args.lr) - layers = tuple(args.layers) - weights = tuple([1.0 / len(layers)] * len(layers)) - - print(f"\nOptimising {args.implementation}/{args.precision} for {args.steps} steps " - f"(layers={layers})\n" + "-" * 52) - first = None - for step in range(args.steps): - opt.zero_grad(set_to_none=True) - sim = model(img, layers=layers, weights=weights) - loss = -sim.mean() # maximise similarity == minimise negative similarity - loss.backward() - opt.step() - with torch.no_grad(): - img.clamp_(0.0, 1.0) - if step == 0: - first = loss.item() - if step % max(1, args.steps // 10) == 0 or step == args.steps - 1: - print(f" step {step:4d} loss={loss.item():+.5f} mean_sim={sim.mean().item():.5f}") - - last = loss.item() - print("-" * 52) - print(f"loss: {first:+.5f} -> {last:+.5f} (reduced by {first - last:.5f})") - assert last < first, "optimisation failed to reduce the loss" - - if args.out: - _save_image(img.detach()[0], args.out) - - -if __name__ == "__main__": - main() diff --git a/puzzle_sim_cuda/puzzle_sim_cuda.py b/puzzle_sim_cuda/puzzle_sim_cuda.py deleted file mode 100644 index b811c37..0000000 --- a/puzzle_sim_cuda/puzzle_sim_cuda.py +++ /dev/null @@ -1,432 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -"""High-level PuzzleSim implementation backed by CUDA. - -Mirrors the API of ``puzzle_sim.PuzzleSim`` but: - -* swaps in custom CUDA kernels for L2 normalization, bilinear upsample, and - a fused tensor-core ``sim_max`` (GEMM + per-row max in a single kernel), -* picks the ``sim_max`` precision at construction time: - - ``"tf32"`` (default): tensor-core kernel, ~1e-3 abs error vs FP32, - - ``"fp16"``: tensor-core kernel with FP16 inputs / FP32 accumulator, - ~5e-3 abs error, fastest, - - ``"fp32"``: chunked ``torch.matmul + max`` fallback for strict-precision - tests or older GPUs without tensor cores, -* packs reference features once at construction into the layout the - contraction expects, so the per-query cost is just one backbone forward - plus one ``sim_max`` per layer. -""" - -from __future__ import annotations - -import contextlib -import os -import sys -from typing import Dict, List, Literal, Optional, Tuple - -import torch -import torch.nn as nn -import torch.nn.functional as F - -from puzzle_sim import Alexnet, ScalingLayer, SqueezeNet, Vgg16, _resize_tensor - - -# The compiled extension is built next to this package. Make sure its directory -# is importable so ``import puzzle_sim_cuda_ext`` resolves regardless of how the -# package was first imported (e.g. before a test ``conftest`` has extended -# ``sys.path``). Using the single top-level name everywhere is important: the -# pybind11 module is single-phase init and must not be loaded under two names. -_PKG_DIR = os.path.dirname(os.path.abspath(__file__)) -if _PKG_DIR not in sys.path: - sys.path.insert(0, _PKG_DIR) - -try: - import puzzle_sim_cuda_ext as _ext # type: ignore[import-not-found] - CUDA_EXT_AVAILABLE = True -except ImportError: # pragma: no cover - exercised via fallback path - _ext = None - CUDA_EXT_AVAILABLE = False - - -Precision = Literal["fp32", "tf32", "fp16"] -_VALID_PRECISIONS = ("fp32", "tf32", "fp16") - - -_NET_CHANNELS: Dict[str, List[int]] = { - "squeeze": [64, 128, 256, 384, 384, 512, 512], - "alex": [64, 192, 384, 256, 256], - "vgg": [64, 128, 256, 512, 512], - "vgg16": [64, 128, 256, 512, 512], -} - - -def _make_backbone(net_type: str) -> nn.Module: - if net_type in ("vgg", "vgg16"): - return Vgg16(pretrained=True, requires_grad=False) - if net_type == "alex": - return Alexnet(pretrained=True, requires_grad=False) - if net_type == "squeeze": - return SqueezeNet(pretrained=True, requires_grad=False) - raise ValueError(f"Unknown net_type: {net_type!r}") - - -def _grad_active(img: torch.Tensor) -> bool: - """True when autograd should record ops for ``img``. - - The custom CUDA kernels have no backward, so the differentiable code paths - only kick in when grad is enabled *and* the input is part of a graph that - requires it (e.g. a learnable image used as a perceptual loss). - """ - return ( - torch.is_grad_enabled() - and isinstance(img, torch.Tensor) - and img.requires_grad - ) - - -def _normalize_features(features: torch.Tensor, eps: float = 1e-8) -> torch.Tensor: - """Channel-wise L2 normalization. - - Uses the CUDA kernel when available and applicable; otherwise falls back to - differentiable PyTorch ops (also used whenever ``features`` carries grad, - since the kernel has no backward). - """ - if ( - features.is_cuda - and CUDA_EXT_AVAILABLE - and features.dtype == torch.float32 - and not features.requires_grad - ): - return _ext.normalize_features(features.contiguous(), eps) - norm = torch.sqrt(eps + features.pow(2).sum(dim=1, keepdim=True)) - return features / norm - - -def _pack_reference(refs: torch.Tensor) -> torch.Tensor: - """Transpose+flatten ``(N, C, H, W)`` references to ``(C, N*H*W)``. - - Done once at construction so the per-call ``sim_max`` does not need to - materialise a transposed view of refs every forward. - """ - if refs.is_cuda and CUDA_EXT_AVAILABLE and refs.dtype == torch.float32: - return _ext.pack_reference(refs.contiguous()) - N, C, H, W = refs.shape - return refs.transpose(0, 1).contiguous().reshape(C, N * H * W) - - -# Peak transient bytes per matmul chunk when computing scores. 256 MB keeps us -# well under typical 6-8 GB free VRAM after the backbone is loaded, and the -# tile is large enough that cuBLAS hits its high-throughput kernels. -_SCORE_CHUNK_BYTES = 256 * 1024 * 1024 - - -def _device_capability_at_least(major: int, minor: int = 0) -> bool: - if not torch.cuda.is_available(): - return False - cap = torch.cuda.get_device_capability() - return cap >= (major, minor) - - -def _validate_precision(precision: str) -> Precision: - if precision not in _VALID_PRECISIONS: - raise ValueError( - f"precision must be one of {_VALID_PRECISIONS!r}, got {precision!r}" - ) - return precision # type: ignore[return-value] - - -def _sim_max( - query_feats: torch.Tensor, - refs_packed: torch.Tensor, - query_hw: Tuple[int, int], - precision: Precision = "fp32", -) -> torch.Tensor: - """Per-pixel max similarity of ``query_feats`` against the packed refs. - - Dispatch: - * ``precision == "tf32"`` / ``"fp16"``: tensor-core kernel from the C++ - extension. ``refs_packed`` must match: FP32 for tf32, FP16 for fp16. - * ``precision == "fp32"``: chunked ``torch.matmul + max``. ``refs_packed`` - must be FP32. - - Args: - query_feats: ``(1, C, qH, qW)`` or ``(C, qH, qW)`` query features - (already L2 normalized). - refs_packed: ``(C, N*rH*rW)`` reference features in the correct dtype. - query_hw: ``(qH, qW)`` of the query. - precision: one of ``"fp32"``, ``"tf32"``, ``"fp16"``. - - Returns: - ``(qH, qW)`` similarity map (always FP32). - """ - if query_feats.dim() == 4: - query_feats = query_feats.squeeze(0) - - C, qH, qW = query_feats.shape - qHW = qH * qW - assert query_hw == (qH, qW) - query_packed = query_feats.reshape(C, qHW).contiguous() - - if ( - precision in ("tf32", "fp16") - and CUDA_EXT_AVAILABLE - and query_packed.is_cuda - and not query_packed.requires_grad - ): - if precision == "tf32": - assert refs_packed.dtype == torch.float32, ( - f"refs_packed must be float32 for tf32 sim_max, got {refs_packed.dtype}" - ) - return _ext.sim_max_tf32(query_packed, refs_packed, [qH, qW]) - # fp16 - assert refs_packed.dtype == torch.float16, ( - f"refs_packed must be float16 for fp16 sim_max, got {refs_packed.dtype}" - ) - return _ext.sim_max_fp16(query_packed.half(), refs_packed, [qH, qW]) - - # FP32 fallback via chunked matmul. Picks a K chunk such that the per-step - # score tile (qHW * chunk) stays under _SCORE_CHUNK_BYTES. - K = refs_packed.size(1) - bytes_per_element = query_packed.element_size() - max_chunk = max(1, _SCORE_CHUNK_BYTES // max(1, qHW * bytes_per_element)) - chunk = min(K, max_chunk) - - q_t = query_packed.transpose(0, 1) # (qHW, C); non-contig view is fine, cuBLAS handles it. - if chunk >= K: - scores = q_t @ refs_packed # (qHW, K) - sim_map = scores.max(dim=1).values - else: - sim_map = torch.full((qHW,), float("-inf"), - device=query_packed.device, - dtype=query_packed.dtype) - for k0 in range(0, K, chunk): - k1 = min(k0 + chunk, K) - partial = q_t @ refs_packed[:, k0:k1] # (qHW, chunk) - torch.maximum(sim_map, partial.max(dim=1).values, out=sim_map) - - return sim_map.reshape(qH, qW) - - -def _bilinear_upsample( - sim_map: torch.Tensor, - out_hw: Tuple[int, int], - align_corners: bool = True, -) -> torch.Tensor: - """Bilinear upsample a 2D ``(H, W)`` similarity map to ``out_hw``.""" - if ( - sim_map.is_cuda - and CUDA_EXT_AVAILABLE - and sim_map.dtype == torch.float32 - and sim_map.dim() == 2 - and not sim_map.requires_grad - ): - return _ext.bilinear_upsample(sim_map.contiguous(), list(out_hw), align_corners) - return F.interpolate( - sim_map.unsqueeze(0).unsqueeze(0), - size=out_hw, - mode="bilinear", - align_corners=align_corners, - ).squeeze(0).squeeze(0) - - -class PuzzleSimCUDA(nn.Module): - """CUDA-accelerated PuzzleSim metric. - - Compared to :class:`puzzle_sim.PuzzleSim`, this implementation: - - * Pre-packs reference features into the layout expected by the - contraction, so this preparation happens once instead of on every - forward. - * Uses custom CUDA kernels for channel-wise L2 normalization, bilinear - upsample, and (for ``precision != "fp32"``) the fused GEMM + max. - * Picks the ``sim_max`` precision via the ``precision`` argument. - - The backbone CNN is still PyTorch's torchvision model in eval mode; that - part of the pipeline is already cuDNN-backed. - - Args: - reference: ``(N, C, H, W)`` tensor with the reference distribution. - net_type: ``'squeeze'`` (default, as in the paper), ``'alex'`` or - ``'vgg'``. - resize: optional ``(H, W)`` to bilinearly resize inputs to before - running the backbone. - precision: one of ``"tf32"`` (default, sm_80+), ``"fp16"`` (sm_70+), - or ``"fp32"`` (chunked cuBLAS GEMM; works everywhere). - """ - - def __init__( - self, - reference: torch.Tensor, - net_type: Literal["alex", "vgg", "squeeze"] = "squeeze", - resize: Optional[Tuple[int, int]] = None, - precision: Precision = "tf32", - ) -> None: - super().__init__() - if net_type not in _NET_CHANNELS: - raise ValueError(f"Unknown net_type: {net_type!r}") - - precision = _validate_precision(precision) - if precision == "tf32" and not _device_capability_at_least(8): - # Tensor-core TF32 needs Ampere. Silently fall back to FP32. - precision = "fp32" - if precision == "fp16" and not _device_capability_at_least(7): - precision = "fp32" - if precision != "fp32" and not CUDA_EXT_AVAILABLE: - precision = "fp32" - - self.net_type = net_type - self.resize = resize - self.precision: Precision = precision - self.chns = _NET_CHANNELS[net_type] - self.L = len(self.chns) - self.device = reference.device - - self.net = _make_backbone(net_type).to(reference.device).eval() - self.scaling_layer = ScalingLayer().to(reference.device) - - for p in self.parameters(): - p.requires_grad = False - - self.reference = reference - # Cached, packed reference features. Filled lazily on first forward so - # we never run a 4090 backbone forward inside __init__ when the user - # might still be moving things around. ``_packed_refs`` always stores - # FP32 versions; ``_packed_refs_fp16`` is populated on demand. - self._packed_refs: Optional[Dict[int, torch.Tensor]] = None - self._packed_refs_fp16: Dict[int, torch.Tensor] = {} - self._ref_shapes: Optional[Dict[int, Tuple[int, int]]] = None - - # ------------------------------------------------------------------ - # Feature extraction - # ------------------------------------------------------------------ - def _scaled_input(self, img: torch.Tensor, normalize: bool) -> torch.Tensor: - if img.dim() == 3: - img = img.unsqueeze(0) - if normalize: - img = 2 * img - 1 - img = self.scaling_layer(img) - if self.resize is not None: - img = _resize_tensor(img, size=self.resize, align_corners=True) - return img - - def compute_features( - self, - img: torch.Tensor, - normalize: bool = False, - ) -> Dict[int, torch.Tensor]: - """Return normalized backbone features for ``img``. - - Gradients flow back to ``img`` when it requires grad and grad is enabled - (the backbone weights stay frozen). Otherwise the call runs under - ``no_grad`` and uses the fast custom kernels, exactly as before. - """ - img = img.to(self.device) - ctx = contextlib.nullcontext() if _grad_active(img) else torch.no_grad() - with ctx: - scaled = self._scaled_input(img, normalize) - outs = self.net.forward(scaled) - return {k: _normalize_features(outs[k]) for k in range(self.L)} - - def _ensure_reference_packed(self) -> None: - if self._packed_refs is not None: - return - with torch.no_grad(): - ref_feats = self.compute_features(self.reference, normalize=True) - self._packed_refs = {} - self._ref_shapes = {} - for k, feats in ref_feats.items(): - self._packed_refs[k] = _pack_reference(feats) - self._ref_shapes[k] = (feats.shape[2], feats.shape[3]) - - def _refs_for_layer(self, layer: int) -> torch.Tensor: - """Return packed refs for ``layer`` in the dtype matching ``self.precision``.""" - assert self._packed_refs is not None - if self.precision == "fp16": - cached = self._packed_refs_fp16.get(layer) - if cached is None: - cached = self._packed_refs[layer].half().contiguous() - self._packed_refs_fp16[layer] = cached - return cached - return self._packed_refs[layer] - - # ------------------------------------------------------------------ - # Forward - # ------------------------------------------------------------------ - def forward( - self, - img: torch.Tensor, - layers: Tuple[int, ...] = (2, 3, 4), - normalize: bool = True, - reduction: Literal["mean", "sum"] = "sum", - weights: Optional[Tuple[float, ...]] = (0.67, 0.2, 0.13), - ) -> torch.Tensor: - """Return a similarity map for ``img`` against the reference distribution.""" - if weights is not None and len(weights) != len(layers): - raise ValueError("Number of weights must match number of layers.") - - self._ensure_reference_packed() - assert self._packed_refs is not None and self._ref_shapes is not None - - if img.dim() == 3: - img = img.unsqueeze(0) - out_hw = img.shape[-2:] - - # When the query carries grad, compute sim_max in exact FP32 (the - # tensor-core kernels have no backward); references stay frozen. - differentiable = _grad_active(img) - query_feats = self.compute_features(img, normalize=normalize) - - sims: List[torch.Tensor] = [] - for i, layer in enumerate(layers): - q = query_feats[layer] - qH, qW = q.shape[2], q.shape[3] - if differentiable: - r = self._packed_refs[layer] - sim_map = _sim_max(q, r, (qH, qW), precision="fp32") - else: - r = self._refs_for_layer(layer) - sim_map = _sim_max(q, r, (qH, qW), precision=self.precision) - if weights is not None: - sim_map = sim_map * weights[i] - sims.append(_bilinear_upsample(sim_map, out_hw, align_corners=True)) - - result = torch.stack(sims, dim=0).sum(dim=0) - if reduction == "mean": - result = result / len(sims) - return result - - -def PuzzleSim( # noqa: N802 - keep parity with original API - reference: torch.Tensor, - net_type: Literal["alex", "vgg", "squeeze"] = "squeeze", - resize: Optional[Tuple[int, int]] = None, - use_cuda: bool = True, - precision: Precision = "tf32", - implementation: Literal["kernel", "fused"] = "kernel", -): - """Drop-in replacement for :class:`puzzle_sim.PuzzleSim`. - - When ``use_cuda`` is true *and* the CUDA extension is built *and* the - reference tensor is on a CUDA device, returns a :class:`PuzzleSimCUDA` - instance (``implementation='kernel'``) or :class:`PuzzleSimCUDAFused` - (``implementation='fused'``). Otherwise falls back to the original PyTorch - implementation. - - The fused implementation is currently only available for - ``net_type='squeeze'``; for other backbones it silently falls back to the - kernel implementation. - """ - if ( - use_cuda - and CUDA_EXT_AVAILABLE - and torch.cuda.is_available() - and reference.is_cuda - ): - if implementation == "fused" and net_type == "squeeze": - from .puzzle_sim_cuda_fused import PuzzleSimCUDAFused - return PuzzleSimCUDAFused(reference, resize=resize, precision=precision) - return PuzzleSimCUDA(reference, net_type=net_type, resize=resize, precision=precision) - from puzzle_sim import PuzzleSim as _RefPuzzleSim - return _RefPuzzleSim(reference, net_type=net_type, resize=resize) - - -__all__ = ["PuzzleSimCUDA", "PuzzleSim", "CUDA_EXT_AVAILABLE", "Precision"] diff --git a/puzzle_sim_cuda/puzzle_sim_cuda_fused.py b/puzzle_sim_cuda/puzzle_sim_cuda_fused.py deleted file mode 100644 index ddef07a..0000000 --- a/puzzle_sim_cuda/puzzle_sim_cuda_fused.py +++ /dev/null @@ -1,245 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -"""Fully fused C++ implementation of PuzzleSim over SqueezeNet1.1. - -Unlike :class:`puzzle_sim_cuda.PuzzleSimCUDA`, which orchestrates the per-layer -backbone / normalize / sim-max / upsample chain in Python, this class hands -the entire pipeline to a single C++ entrypoint. The C++ side owns: - -* the SqueezeNet weights (pre-extracted from torchvision once at construction), -* the cuDNN handle that backs ``at::cudnn_convolution_relu`` (the fused - conv + bias + ReLU kernel), -* the packed, cached reference features per layer, -* the tensor-core ``sim_max`` kernels from this extension. - -The only work that stays in Python is the (cheap) scaling layer + optional -input resize, plus turning the dict of weights into the order the C++ class -expects. Per forward, there is exactly one round-trip into C++. -""" - -from __future__ import annotations - -from typing import Dict, List, Literal, Optional, Tuple - -import torch -import torch.nn as nn - -from puzzle_sim import ScalingLayer, SqueezeNet, _resize_tensor - -# Reuse the exact module object the kernel path already imported (it also makes -# sure the package directory is on sys.path). Sharing the single instance avoids -# loading the single-phase pybind11 extension under two different names. -from .puzzle_sim_cuda import _ext, _grad_active - - -_HAVE_FUSED = _ext is not None and hasattr(_ext, "FusedSqueezeNet") - - -Precision = Literal["fp32", "tf32", "fp16"] -_VALID_PRECISIONS = ("fp32", "tf32", "fp16") - - -def _device_capability_at_least(major: int, minor: int = 0) -> bool: - if not torch.cuda.is_available(): - return False - cap = torch.cuda.get_device_capability() - return cap >= (major, minor) - - -def _extract_squeeze_weights(net: SqueezeNet) -> List[torch.Tensor]: - """Flatten the SqueezeNet1.1 backbone weights into the 50-tensor list - the C++ ``FusedSqueezeNet`` constructor expects. - - Layout (see ``src/fused_inference.cpp``): - [0] conv0.weight (64, 3, 3, 3) - [1] conv0.bias (64,) - [2..49] eight Fire modules, each contributing six tensors in order - squeeze.weight, squeeze.bias, - expand1x1.weight, expand1x1.bias, - expand3x3.weight, expand3x3.bias. - """ - weights: List[torch.Tensor] = [] - weights.append(net.slices[0][0].weight.detach().contiguous()) - weights.append(net.slices[0][0].bias.detach().contiguous()) - fires_seen = 0 - for s_idx in range(1, 7): - for m in net.slices[s_idx]: - if hasattr(m, "squeeze") and hasattr(m, "expand1x1") and hasattr(m, "expand3x3"): - weights.append(m.squeeze.weight.detach().contiguous()) - weights.append(m.squeeze.bias.detach().contiguous()) - weights.append(m.expand1x1.weight.detach().contiguous()) - weights.append(m.expand1x1.bias.detach().contiguous()) - weights.append(m.expand3x3.weight.detach().contiguous()) - weights.append(m.expand3x3.bias.detach().contiguous()) - fires_seen += 1 - assert fires_seen == 8, f"Expected 8 Fire modules in SqueezeNet1.1, got {fires_seen}" - assert len(weights) == 50, f"Expected 50 weight tensors, got {len(weights)}" - return weights - - -class PuzzleSimCUDAFused(nn.Module): - """End-to-end fused PuzzleSim over SqueezeNet1.1. - - Numerically equivalent to :class:`puzzle_sim_cuda.PuzzleSimCUDA` with - ``net_type='squeeze'`` at the same ``precision``, but it bundles the - backbone forward, normalize, sim-max and upsample into one C++ call. - - Currently only the SqueezeNet backbone is supported; AlexNet/VGG will - follow the same pattern. - - Args: - reference: ``(N, 3, H, W)`` reference distribution. - resize: optional ``(H, W)`` target. Applied as in the reference - ``puzzle_sim`` implementation (``area`` mode when downscaling, - anti-aliased bilinear otherwise). - precision: one of ``"tf32"`` (default, sm_80+), ``"fp16"`` (sm_70+), - ``"fp32"``. Bound to the ``sim_max`` step; the cuDNN convolutions - silently use TF32 internally when ``torch.backends.cudnn.allow_tf32`` - is true (matches the kernel-path behaviour). - - Gradients: the fused inference path bypasses autograd, so when a forward is - called with a query that requires grad (e.g. optimising an image against the - reference distribution) it transparently delegates to a kernel-mode model - with exact FP32 ``sim_max``. ``loss.backward()`` then populates the query's - ``.grad``; the backbone weights and references stay frozen. - """ - - def __init__( - self, - reference: torch.Tensor, - resize: Optional[Tuple[int, int]] = None, - precision: Precision = "tf32", - ) -> None: - super().__init__() - if not _HAVE_FUSED: - raise RuntimeError( - "PuzzleSimCUDAFused requires the puzzle_sim_cuda_ext CUDA extension " - "with the fused inference module built in. Rebuild the extension." - ) - if not reference.is_cuda: - raise RuntimeError( - "PuzzleSimCUDAFused requires reference to live on a CUDA device." - ) - if precision not in _VALID_PRECISIONS: - raise ValueError(f"precision must be one of {_VALID_PRECISIONS!r}, got {precision!r}") - if precision == "tf32" and not _device_capability_at_least(8): - precision = "fp32" - if precision == "fp16" and not _device_capability_at_least(7): - precision = "fp32" - - self.resize = resize - self.precision: Precision = precision - self.device = reference.device - - backbone = SqueezeNet(pretrained=True, requires_grad=False).to(reference.device).eval() - for p in backbone.parameters(): - p.requires_grad = False - weights = _extract_squeeze_weights(backbone) - self._backbone = backbone # kept alive so weight tensors stay valid - - self.scaling_layer = ScalingLayer().to(reference.device) - - self._fused = _ext.FusedSqueezeNet(weights, precision) - self.reference = reference - self._ref_layers: Optional[Tuple[int, ...]] = None - # Lazily built when a forward needs gradients (see _grad_forward). - self._grad_model: Optional[nn.Module] = None - - # ------------------------------------------------------------------ - # Input preprocessing kept in Python; the heavy lifting lives in C++. - # ------------------------------------------------------------------ - def _scaled_input(self, img: torch.Tensor, normalize: bool) -> torch.Tensor: - if img.dim() == 3: - img = img.unsqueeze(0) - if normalize: - img = 2 * img - 1 - img = self.scaling_layer(img) - if self.resize is not None: - img = _resize_tensor(img, size=self.resize, align_corners=True) - return img.contiguous() - - def _ensure_reference_packed(self, layers: Tuple[int, ...]) -> None: - if self._ref_layers is not None and tuple(self._ref_layers) == tuple(layers): - return - with torch.no_grad(): - scaled_refs = self._scaled_input(self.reference, normalize=True) - self._fused.set_reference(scaled_refs, list(layers)) - self._ref_layers = tuple(layers) - - # Public for parity with PuzzleSimCUDA tests + benchmarks. - def compute_features( - self, - img: torch.Tensor, - normalize: bool = False, - layers: Tuple[int, ...] = (0, 1, 2, 3, 4, 5, 6), - ) -> Dict[int, torch.Tensor]: - img = img.to(self.device) - with torch.no_grad(): - scaled = self._scaled_input(img, normalize) - return self._fused.compute_features(scaled, list(layers)) - - def _grad_forward( - self, - img: torch.Tensor, - layers: Tuple[int, ...], - normalize: bool, - reduction: Literal["mean", "sum"], - weights: Optional[Tuple[float, ...]], - ) -> torch.Tensor: - """Differentiable forward for query-image gradients. - - The fused C++ path has no backward (it bypasses autograd entirely), so - when ``img`` carries grad we route through a kernel-mode model built - from the same pretrained weights and reference. That path computes the - backbone with torchvision (frozen weights, grad w.r.t. the input) and an - exact FP32 ``sim_max``, so ``loss.backward()`` populates ``img.grad``. - """ - if self._grad_model is None: - from .puzzle_sim_cuda import PuzzleSimCUDA - - self._grad_model = PuzzleSimCUDA( - self.reference, - net_type="squeeze", - resize=self.resize, - precision="fp32", - ) - return self._grad_model( - img, - layers=layers, - normalize=normalize, - reduction=reduction, - weights=weights, - ) - - def forward( - self, - img: torch.Tensor, - layers: Tuple[int, ...] = (2, 3, 4), - normalize: bool = True, - reduction: Literal["mean", "sum"] = "sum", - weights: Optional[Tuple[float, ...]] = (0.67, 0.2, 0.13), - ) -> torch.Tensor: - if weights is not None and len(weights) != len(layers): - raise ValueError("Number of weights must match number of layers.") - - if _grad_active(img): - return self._grad_forward(img, layers, normalize, reduction, weights) - - self._ensure_reference_packed(tuple(layers)) - - if img.dim() == 3: - img = img.unsqueeze(0) - out_hw = (int(img.shape[-2]), int(img.shape[-1])) - - with torch.no_grad(): - scaled = self._scaled_input(img.to(self.device), normalize) - w_list = [float(w) for w in weights] if weights is not None else [] - return self._fused.forward( - scaled, - list(layers), - w_list, - reduction, - list(out_hw), - ) - - -__all__ = ["PuzzleSimCUDAFused", "Precision"] diff --git a/puzzle_sim_cuda/requirements.txt b/puzzle_sim_cuda/requirements.txt deleted file mode 100644 index ad0bbb4..0000000 --- a/puzzle_sim_cuda/requirements.txt +++ /dev/null @@ -1,17 +0,0 @@ -# PuzzleSim CUDA Requirements - -# Core dependencies -torch>=1.13.0 -torchvision>=0.14.0 -numpy>=1.21.0 - -# Build dependencies -pybind11>=2.10.0 - -# Optional dependencies for development and testing -matplotlib>=3.5.0 # For plotting and visualization -pillow>=9.0.0 # For image loading in tests - -# Original PuzzleSim dependencies -torchmetrics>=1.0.0 - diff --git a/puzzle_sim_cuda/setup.py b/puzzle_sim_cuda/setup.py deleted file mode 100644 index 5bfa63f..0000000 --- a/puzzle_sim_cuda/setup.py +++ /dev/null @@ -1,62 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -"""Build script for the PuzzleSim CUDA extension. - -Run ``pip install -e .`` from this directory, or ``python setup.py build_ext --inplace`` -to drop the extension next to the Python sources. -""" - -import os - -import torch -from setuptools import setup -from torch.utils.cpp_extension import BuildExtension, CUDAExtension - - -def _detected_arch() -> list[str]: - """Return a TORCH_CUDA_ARCH_LIST-compatible list.""" - env = os.environ.get("TORCH_CUDA_ARCH_LIST") - if env: - return [a.strip() for a in env.split(";") if a.strip()] - if torch.cuda.is_available(): - major, minor = torch.cuda.get_device_capability() - return [f"{major}.{minor}"] - # Reasonable defaults for the GPUs we expect to see. - return ["7.0", "7.5", "8.0", "8.6", "8.9", "9.0"] - - -arch_list = _detected_arch() -os.environ.setdefault("TORCH_CUDA_ARCH_LIST", ";".join(arch_list)) - -ext_modules = [ - CUDAExtension( - name="puzzle_sim_cuda_ext", - sources=[ - "src/puzzle_sim_cuda.cpp", - "src/fused_inference.cpp", - "src/kernels.cu", - ], - extra_compile_args={ - "cxx": ["/O2"] if os.name == "nt" else ["-O3"], - "nvcc": [ - "-O3", - "--use_fast_math", - "--expt-relaxed-constexpr", - # Newer host compilers (e.g. MSVC 2026) are not yet on the - # CUDA toolkit's supported list but still produce correct code. - "-allow-unsupported-compiler", - ], - }, - ), -] - -setup( - name="puzzle_sim_cuda", - version="0.2.0", - description="CUDA-accelerated PuzzleSim implementation", - packages=["puzzle_sim_cuda"], - package_dir={"puzzle_sim_cuda": "."}, - ext_modules=ext_modules, - cmdclass={"build_ext": BuildExtension}, - zip_safe=False, - python_requires=">=3.8", -) diff --git a/puzzle_sim_cuda/src/fused_inference.cpp b/puzzle_sim_cuda/src/fused_inference.cpp deleted file mode 100644 index 2c19ba3..0000000 --- a/puzzle_sim_cuda/src/fused_inference.cpp +++ /dev/null @@ -1,529 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -// -// Fully fused PuzzleSim forward over the SqueezeNet1.1 backbone. Owns: -// * pre-extracted, contiguous weight + bias tensors, -// * pre-packed reference features (one per requested layer), -// * the entire backbone -> normalize -> sim_max -> upsample -> weighted-sum -// pipeline, executed back-to-back in a single C++ call so there is no -// Python dispatch between the 8 Fire modules / 3 taps. -// -// Convolutions go through at::cudnn_convolution_relu, which is PyTorch's -// thin wrapper around cudnnConvolutionBiasActivationForward (single fused -// conv + bias + ReLU cuDNN op). Max-pool uses at::max_pool2d. The custom -// kernels (normalize / sim_max / bilinear_upsample) are reused from -// kernels.cu via the existing C-linkage launchers. - -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -// Forward declarations of the C-linkage kernel launchers from kernels.cu -extern "C" { -void launch_normalize_features( - const float* input, float* output, - int batch_size, int channels, int height, int width, - float eps, cudaStream_t stream); - -void launch_sim_max_tf32( - const float* Q, const float* R, - float* out, float* partial_max, - int C_padded, int qHW_padded, int K_padded, - int qHW, int K, cudaStream_t stream); - -void launch_sim_max_fp16( - const __half* Q, const __half* R, - float* out, float* partial_max, - int C_padded, int qHW_padded, int K_padded, - int qHW, int K, cudaStream_t stream); - -int sim_max_tile_m(); -int sim_max_tile_n(); - -void launch_bilinear_upsample( - const float* input, float* output, - int in_h, int in_w, int out_h, int out_w, - bool align_corners, cudaStream_t stream); -} - -namespace fused { - -namespace { - -// SqueezeNet1.1 weight layout. The constructor receives a flat std::vector -// of tensors; these indices document where each weight lives. -// -// [0] conv0.weight (64, 3, 3, 3) -// [1] conv0.bias (64,) -// [2 + 6*k + 0] fire[k].squeeze.weight -// [2 + 6*k + 1] fire[k].squeeze.bias -// [2 + 6*k + 2] fire[k].expand1x1.weight -// [2 + 6*k + 3] fire[k].expand1x1.bias -// [2 + 6*k + 4] fire[k].expand3x3.weight -// [2 + 6*k + 5] fire[k].expand3x3.bias -// for k = 0..7. -constexpr int N_FIRES = 8; -constexpr int N_TENSORS = 2 + 6 * N_FIRES; // 50 - -inline cudaStream_t current_stream() { - return at::cuda::getCurrentCUDAStream(); -} - -inline int round_up(int x, int mult) { - return ((x + mult - 1) / mult) * mult; -} - -inline at::Tensor maybe_pad_2d(const at::Tensor& t, int new_rows, int new_cols) { - if (t.size(0) == new_rows && t.size(1) == new_cols) { - return t; - } - auto padded = torch::zeros({new_rows, new_cols}, t.options()); - padded.narrow(0, 0, t.size(0)).narrow(1, 0, t.size(1)).copy_(t); - return padded; -} - -inline at::Tensor conv_relu( - const at::Tensor& x, - const at::Tensor& w, - const at::Tensor& b, - std::vector stride, - std::vector padding) -{ - // cuDNN-backed conv + bias + ReLU in one op. - return at::cudnn_convolution_relu( - x, w, b, - at::IntArrayRef(stride), - at::IntArrayRef(padding), - at::IntArrayRef({1, 1}), // dilation - /*groups=*/1); -} - -// Fire module: squeeze (1x1) -> expand_1x1 (1x1) concat expand_3x3 (3x3). -inline at::Tensor fire_forward( - const at::Tensor& x, - const at::Tensor& sq_w, const at::Tensor& sq_b, - const at::Tensor& e1_w, const at::Tensor& e1_b, - const at::Tensor& e3_w, const at::Tensor& e3_b) -{ - auto sq = conv_relu(x, sq_w, sq_b, {1, 1}, {0, 0}); - auto e1 = conv_relu(sq, e1_w, e1_b, {1, 1}, {0, 0}); - auto e3 = conv_relu(sq, e3_w, e3_b, {1, 1}, {1, 1}); - return at::cat({e1, e3}, /*dim=*/1); -} - -inline at::Tensor maxpool_3x3_s2_ceil(const at::Tensor& x) { - return at::max_pool2d( - x, - /*kernel_size=*/at::IntArrayRef({3, 3}), - /*stride=*/at::IntArrayRef({2, 2}), - /*padding=*/at::IntArrayRef({0, 0}), - /*dilation=*/at::IntArrayRef({1, 1}), - /*ceil_mode=*/true); -} - -// Channel-wise L2 normalize via the existing CUDA kernel. -inline at::Tensor normalize_features(const at::Tensor& x, double eps = 1e-8) { - TORCH_CHECK(x.is_cuda(), "normalize_features requires a CUDA tensor"); - TORCH_CHECK(x.dim() == 4, "normalize_features expects 4D (N, C, H, W)"); - auto x_c = x.contiguous(); - auto out = torch::empty_like(x_c); - launch_normalize_features( - x_c.data_ptr(), - out.data_ptr(), - static_cast(x_c.size(0)), - static_cast(x_c.size(1)), - static_cast(x_c.size(2)), - static_cast(x_c.size(3)), - static_cast(eps), - current_stream()); - return out; -} - -// Pack (N, C, H, W) -> (C, N*H*W). Same convention as the existing -// pack_reference kernel; kept as a thin wrapper here so we can call it -// from C++ on the L2-normalized backbone outputs. -inline at::Tensor pack_features(const at::Tensor& feats) { - TORCH_CHECK(feats.dim() == 4, "pack_features expects 4D (N, C, H, W)"); - const auto N = feats.size(0); - const auto C = feats.size(1); - const auto H = feats.size(2); - const auto W = feats.size(3); - return feats.transpose(0, 1).contiguous().reshape({C, N * H * W}); -} - -// Tensor-core fused GEMM + per-row max. Mirrors the bindings in -// puzzle_sim_cuda.cpp; we duplicate here to keep this translation unit -// self-contained for the fused class. -inline at::Tensor sim_max_dispatch( - const at::Tensor& query_packed, // (C, qHW) - const at::Tensor& refs_packed, // (C, K) - int qH, int qW, - const std::string& precision) -{ - const int TC_TILE_M = sim_max_tile_m(); - const int TC_TILE_N = sim_max_tile_n(); - - const int C = static_cast(query_packed.size(0)); - const int qHW = static_cast(query_packed.size(1)); - const int K = static_cast(refs_packed.size(1)); - TORCH_CHECK(qH * qW == qHW, "query_hw does not match query_packed.shape[1]"); - - if (precision == "fp32") { - // Chunked matmul + max fallback. Mirrors the Python fallback exactly - // but keeps everything on stream without round-tripping to Python. - constexpr int64_t SCORE_CHUNK_BYTES = 256LL * 1024 * 1024; - const int64_t bytes_per = query_packed.element_size(); - const int64_t max_chunk = - std::max(1, SCORE_CHUNK_BYTES / std::max(1, qHW * bytes_per)); - const int64_t chunk = std::min(K, max_chunk); - - auto q_t = query_packed.transpose(0, 1); // (qHW, C) - if (chunk >= K) { - auto scores = at::matmul(q_t, refs_packed); // (qHW, K) - auto sim = std::get<0>(scores.max(/*dim=*/1)); - return sim.reshape({qH, qW}); - } - auto sim_map = torch::full({qHW}, - -std::numeric_limits::infinity(), - query_packed.options()); - for (int64_t k0 = 0; k0 < K; k0 += chunk) { - int64_t k1 = std::min(k0 + chunk, K); - auto partial = at::matmul(q_t, refs_packed.narrow(/*dim=*/1, k0, k1 - k0)); - auto partial_max = std::get<0>(partial.max(/*dim=*/1)); - sim_map = at::maximum(sim_map, partial_max); - } - return sim_map.reshape({qH, qW}); - } - - // Tensor-core path - const bool fp16 = (precision == "fp16"); - const int WMMA_K = fp16 ? 16 : 8; - const int C_padded = round_up(C, WMMA_K); - const int qHW_padded = round_up(qHW, TC_TILE_M); - const int K_padded = round_up(K, TC_TILE_N); - const int n_chunks = K_padded / TC_TILE_N; - - auto Q = maybe_pad_2d(query_packed, C_padded, qHW_padded); - auto R = maybe_pad_2d(refs_packed, C_padded, K_padded); - - auto float_opts = query_packed.options().dtype(at::kFloat); - auto out = torch::empty({qH, qW}, float_opts); - auto partial = torch::empty({qHW_padded, n_chunks}, float_opts); - - if (fp16) { - launch_sim_max_fp16( - reinterpret_cast(Q.data_ptr()), - reinterpret_cast(R.data_ptr()), - out.data_ptr(), - partial.data_ptr(), - C_padded, qHW_padded, K_padded, qHW, K, - current_stream()); - } else { - launch_sim_max_tf32( - Q.data_ptr(), - R.data_ptr(), - out.data_ptr(), - partial.data_ptr(), - C_padded, qHW_padded, K_padded, qHW, K, - current_stream()); - } - return out; -} - -inline at::Tensor bilinear_upsample( - const at::Tensor& x, int64_t out_h, int64_t out_w, bool align_corners) -{ - TORCH_CHECK(x.is_cuda() && x.dim() == 2 && x.scalar_type() == at::kFloat, - "bilinear_upsample expects a 2D float CUDA tensor"); - auto x_c = x.contiguous(); - auto out = torch::empty({out_h, out_w}, x_c.options()); - launch_bilinear_upsample( - x_c.data_ptr(), - out.data_ptr(), - static_cast(x_c.size(0)), static_cast(x_c.size(1)), - static_cast(out_h), static_cast(out_w), - align_corners, - current_stream()); - return out; -} - -} // namespace - -// ===================================================================== -// FusedSqueezeNet - holds packed weights + cached reference features, -// runs the full PuzzleSim pipeline in a single C++ call. -// ===================================================================== -class FusedSqueezeNet { -public: - FusedSqueezeNet(std::vector weights, - const std::string& precision) - : w_(std::move(weights)), precision_(precision) - { - TORCH_CHECK( - static_cast(w_.size()) == N_TENSORS, - "FusedSqueezeNet expects ", N_TENSORS, " weight tensors, got ", w_.size()); - for (size_t i = 0; i < w_.size(); ++i) { - TORCH_CHECK(w_[i].is_cuda(), "weight ", i, " must be CUDA"); - TORCH_CHECK(w_[i].scalar_type() == at::kFloat, - "weight ", i, " must be float32; got ", w_[i].scalar_type()); - if (!w_[i].is_contiguous()) { - w_[i] = w_[i].contiguous(); - } - } - validate_precision(precision_); - } - - // Run the SqueezeNet backbone on `scaled_img` and return the - // L2-normalized feature maps at the requested slice indices. - // - // `scaled_img` is expected to be (1, 3, H, W) and to have already - // been through any scaling layer + optional resize (kept in Python). - std::map compute_features( - at::Tensor scaled_img, - std::vector layers) - { - TORCH_CHECK(scaled_img.is_cuda(), "scaled_img must be CUDA"); - if (scaled_img.dim() == 3) scaled_img = scaled_img.unsqueeze(0); - TORCH_CHECK(scaled_img.dim() == 4 && scaled_img.size(1) == 3, - "scaled_img must be (N, 3, H, W)"); - - std::map tap_raw = forward_backbone(scaled_img, layers); - - std::map out; - for (auto& kv : tap_raw) { - out[kv.first] = normalize_features(kv.second); - } - return out; - } - - // Pack & cache reference features. Stores `(C, K)` packed tensors - // (FP32 by default; FP16 mirror is built lazily for the fp16 precision - // path the first time it is needed for a layer). - // - // `scaled_refs` is the reference distribution after scaling + resize, - // shape `(N, 3, H, W)`. - void set_reference(at::Tensor scaled_refs, - std::vector layers) - { - auto feats = compute_features(std::move(scaled_refs), layers); - refs_packed_.clear(); - refs_packed_fp16_.clear(); - ref_hw_.clear(); - for (auto& kv : feats) { - const auto& f = kv.second; - refs_packed_[kv.first] = pack_features(f); - ref_hw_[kv.first] = std::make_pair( - f.size(2), f.size(3)); - } - } - - bool has_reference() const { - return !refs_packed_.empty(); - } - - // The whole pipeline in one call. Returns a (out_h, out_w) similarity map. - at::Tensor forward(at::Tensor scaled_img, - std::vector layers, - std::vector weights, - const std::string& reduction, - std::vector out_hw) - { - TORCH_CHECK(!refs_packed_.empty(), - "set_reference must be called before forward"); - TORCH_CHECK(out_hw.size() == 2, "out_hw must be of length 2"); - TORCH_CHECK(weights.empty() || weights.size() == layers.size(), - "weights size must match layers size or be empty"); - - auto feats = compute_features(std::move(scaled_img), layers); - - at::Tensor sum_map; - bool first = true; - for (size_t i = 0; i < layers.size(); ++i) { - int64_t layer = layers[i]; - auto fit = feats.find(layer); - auto rit = refs_packed_.find(layer); - auto hit = ref_hw_.find(layer); - TORCH_CHECK(fit != feats.end(), "missing query feats for layer ", layer); - TORCH_CHECK(rit != refs_packed_.end(), - "missing packed refs for layer ", layer, - " - call set_reference with this layer first"); - (void)hit; // ref_hw is kept for callers that want it; not needed here - - // Re-pack: (1, C, qH, qW) -> (C, qHW) - const auto& q = fit->second; - TORCH_CHECK(q.dim() == 4, "query feats must be 4D"); - const int qH = static_cast(q.size(2)); - const int qW = static_cast(q.size(3)); - const int C = static_cast(q.size(1)); - auto q_packed = q.reshape({C, qH * qW}).contiguous(); - - // Picks the right refs tensor based on precision. - at::Tensor r_packed = refs_for_layer(layer); - if (precision_ == "fp16") { - q_packed = q_packed.to(at::kHalf).contiguous(); - } - - auto sim_map = sim_max_dispatch(q_packed, r_packed, qH, qW, precision_); - auto up_map = bilinear_upsample(sim_map, out_hw[0], out_hw[1], /*align_corners=*/true); - if (!weights.empty()) { - up_map = up_map * weights[i]; - } - if (first) { - sum_map = up_map; - first = false; - } else { - sum_map = sum_map + up_map; - } - } - - if (reduction == "mean" && !layers.empty()) { - sum_map = sum_map / static_cast(layers.size()); - } - return sum_map; - } - - std::string precision() const { return precision_; } - - void set_precision(const std::string& p) { - validate_precision(p); - precision_ = p; - // Drop the FP16 cache so it gets rebuilt with the right dtype. - refs_packed_fp16_.clear(); - } - -private: - static void validate_precision(const std::string& p) { - TORCH_CHECK(p == "fp32" || p == "tf32" || p == "fp16", - "precision must be one of {fp32, tf32, fp16}; got ", p); - } - - // Run the backbone and harvest the requested tap outputs. - std::map forward_backbone( - at::Tensor x, - const std::vector& layers) - { - // Layer index -> tap point in the topology: - // layer 0: conv0+relu - // layer 1: slice1 last fire (idx 1) - // layer 2: slice2 last fire (idx 3) - // layer 3: slice3 last fire (idx 4) - // layer 4: slice4 (idx 5) - // layer 5: slice5 (idx 6) - // layer 6: slice6 (idx 7) - std::map want; - int64_t max_layer = -1; - for (auto l : layers) { - want[l] = true; - if (l > max_layer) max_layer = l; - } - - std::map out; - - // Slice 0: conv0 (stride 2, padding 0) + ReLU. - x = conv_relu(x, w_[0], w_[1], {2, 2}, {0, 0}); - if (want.count(0)) out[0] = x; - if (max_layer == 0) return out; - - // Slice 1: maxpool, fire 0 (in=64), fire 1 (in=128, out=128). - x = maxpool_3x3_s2_ceil(x); - x = fire_at(x, 0); - x = fire_at(x, 1); - if (want.count(1)) out[1] = x; - if (max_layer == 1) return out; - - // Slice 2: maxpool, fire 2 (in=128, out=256), fire 3 (in=256, out=256). - x = maxpool_3x3_s2_ceil(x); - x = fire_at(x, 2); - x = fire_at(x, 3); - if (want.count(2)) out[2] = x; - if (max_layer == 2) return out; - - // Slice 3: maxpool, fire 4 (in=256, out=384). - x = maxpool_3x3_s2_ceil(x); - x = fire_at(x, 4); - if (want.count(3)) out[3] = x; - if (max_layer == 3) return out; - - // Slice 4: fire 5 (in=384, out=384). - x = fire_at(x, 5); - if (want.count(4)) out[4] = x; - if (max_layer == 4) return out; - - // Slice 5: fire 6 (in=384, out=512). - x = fire_at(x, 6); - if (want.count(5)) out[5] = x; - if (max_layer == 5) return out; - - // Slice 6: fire 7 (in=512, out=512). - x = fire_at(x, 7); - if (want.count(6)) out[6] = x; - return out; - } - - inline at::Tensor fire_at(const at::Tensor& x, int k) { - const int base = 2 + 6 * k; - return fire_forward( - x, - w_[base + 0], w_[base + 1], // squeeze - w_[base + 2], w_[base + 3], // expand 1x1 - w_[base + 4], w_[base + 5]); // expand 3x3 - } - - const at::Tensor& refs_for_layer(int64_t layer) { - auto& fp32 = refs_packed_.at(layer); - if (precision_ != "fp16") return fp32; - auto it = refs_packed_fp16_.find(layer); - if (it == refs_packed_fp16_.end()) { - it = refs_packed_fp16_.emplace( - layer, fp32.to(at::kHalf).contiguous()).first; - } - return it->second; - } - - std::vector w_; - std::map refs_packed_; - std::map refs_packed_fp16_; - std::map> ref_hw_; - std::string precision_; -}; - -} // namespace fused - -// ----------------------------------------------------------------------------- -// pybind11 registration. Symbol-visible from the main puzzle_sim_cuda.cpp via -// a register_fused_inference(module&) helper invoked inside PYBIND11_MODULE. -// ----------------------------------------------------------------------------- -void register_fused_inference(pybind11::module& m) { - namespace py = pybind11; - py::class_(m, "FusedSqueezeNet") - .def(py::init, std::string>(), - py::arg("weights"), - py::arg("precision") = "tf32") - .def("compute_features", &fused::FusedSqueezeNet::compute_features, - py::arg("scaled_img"), - py::arg("layers"), - "Run scaling-free backbone + L2-normalize. Returns dict layer -> tensor.") - .def("set_reference", &fused::FusedSqueezeNet::set_reference, - py::arg("scaled_refs"), - py::arg("layers"), - "Compute and cache packed reference features.") - .def("has_reference", &fused::FusedSqueezeNet::has_reference, - "True once set_reference has been called.") - .def("forward", &fused::FusedSqueezeNet::forward, - py::arg("scaled_img"), - py::arg("layers"), - py::arg("weights"), - py::arg("reduction") = "sum", - py::arg("out_hw"), - "Full PuzzleSim forward in one C++ call. Returns (H, W) sim map.") - .def_property("precision", - &fused::FusedSqueezeNet::precision, - &fused::FusedSqueezeNet::set_precision); -} diff --git a/puzzle_sim_cuda/tests/__init__.py b/puzzle_sim_cuda/tests/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/puzzle_sim_cuda/tests/conftest.py b/puzzle_sim_cuda/tests/conftest.py deleted file mode 100644 index 2b3c1c6..0000000 --- a/puzzle_sim_cuda/tests/conftest.py +++ /dev/null @@ -1,98 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -"""Shared pytest fixtures for the CUDA test suite.""" - -from __future__ import annotations - -import os -import sys -from pathlib import Path - -import pytest -import torch - -# Make sure we can import both ``puzzle_sim`` (reference) and -# ``puzzle_sim_cuda`` (wrapper) regardless of where pytest is invoked from. -_REPO_ROOT = Path(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))) -_PKG_DIR = Path(os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) -for p in (_REPO_ROOT, _PKG_DIR): - sp = str(p) - if sp not in sys.path: - sys.path.insert(0, sp) - - -def _have_cuda() -> bool: - return torch.cuda.is_available() - - -def _have_ext() -> bool: - try: - import puzzle_sim_cuda_ext # noqa: F401 - except ImportError: - return False - return True - - -def _demo_dataset_dir(name: str) -> Path | None: - """Return the path to a demo-data sample directory, or ``None`` if missing. - - Used by tests that need real images. We skip rather than fail when the - data is unavailable so the suite still passes on machines that don't - have the demo submodule checked out. - """ - base = _REPO_ROOT / "PuzzleSim-demo-data" / "samples" / name - if not base.is_dir(): - return None - if not (base / "prior").is_dir() or not (base / "test").is_dir(): - return None - return base - - -requires_cuda = pytest.mark.skipif(not _have_cuda(), reason="CUDA not available") -requires_ext = pytest.mark.skipif(not _have_ext(), reason="CUDA extension not built") - - -def requires_demo_data(name: str): - """Skip marker for tests that need the named demo dataset.""" - return pytest.mark.skipif( - _demo_dataset_dir(name) is None, - reason=f"demo dataset {name!r} not available", - ) - - -@pytest.fixture(autouse=True) -def _seed_torch(): - """Make every test deterministic.""" - torch.manual_seed(0) - if torch.cuda.is_available(): - torch.cuda.manual_seed_all(0) - - -@pytest.fixture(scope="session") -def device() -> str: - return "cuda" if torch.cuda.is_available() else "cpu" - - -@pytest.fixture(scope="session") -def garden_data() -> tuple[torch.Tensor, torch.Tensor, list[str]] | None: - """Load the garden demo dataset onto the GPU once per session. - - Returns ``(priors, tests, test_names)`` or ``None`` if the data is missing. - """ - base = _demo_dataset_dir("garden") - if base is None: - return None - from PIL import Image - import torchvision.transforms.functional as TF - - def _load_dir(dir_path: Path): - names = sorted(p.name for p in dir_path.iterdir() if p.suffix.lower() == ".png") - imgs = [] - for n in names: - im = Image.open(dir_path / n).convert("RGB") - imgs.append(TF.to_tensor(im).unsqueeze(0)) - return torch.cat(imgs, dim=0), names - - device = "cuda" if torch.cuda.is_available() else "cpu" - priors, _ = _load_dir(base / "prior") - tests, test_names = _load_dir(base / "test") - return priors.to(device), tests.to(device), test_names diff --git a/puzzle_sim_cuda/tests/test_fused.py b/puzzle_sim_cuda/tests/test_fused.py deleted file mode 100644 index 152abbf..0000000 --- a/puzzle_sim_cuda/tests/test_fused.py +++ /dev/null @@ -1,271 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -"""Correctness tests for the fully-fused C++ implementation. - -``PuzzleSimCUDAFused`` collapses the SqueezeNet1.1 backbone + L2 normalize + -sim_max + bilinear upsample into a single C++ entrypoint. These tests make -sure that, at every supported precision, it produces (up to mode tolerance) -the same output as the kernel implementation ``PuzzleSimCUDA``. - -We also exercise: - -* the feature-extraction subpath, against the reference torchvision SqueezeNet, -* construction-time precision fallback (tf32/fp16 -> fp32 on unsupported - hardware) - this is identical to the kernel-path behaviour, -* the ``PuzzleSim`` factory's ``implementation='fused'`` selector, -* edge cases: per-layer-set selection, repeated forwards, multi-image batch. -""" - -from __future__ import annotations - -import pytest -import torch - -from .conftest import requires_cuda, requires_ext, requires_demo_data - - -# Tolerances against the kernel implementation. fp32 is looser than -# test_tensor_cores because the fused path uses ``at::cudnn_convolution_relu`` -# (a fused conv+bias+ReLU cuDNN op) while the kernel path uses the standard -# ``at::conv2d`` + ``F.relu``. Both run via cuDNN, but each can pick a -# different convolution algorithm, so the per-layer activations agree only to -# within ~1e-4 even with TF32 disabled. Downstream the metric is then summed -# over three taps; the empirical end-to-end drift is ~2e-4. -_TOLERANCE = {"fp32": 2e-4, "tf32": 1e-3, "fp16": 5e-3} - - -def _device_capability_at_least(major: int, minor: int = 0) -> bool: - if not torch.cuda.is_available(): - return False - cap = torch.cuda.get_device_capability() - return cap >= (major, minor) - - -_SKIP_TF32 = pytest.mark.skipif( - not _device_capability_at_least(8), - reason="TF32 tensor cores require compute capability >= 8.0", -) -_SKIP_FP16 = pytest.mark.skipif( - not _device_capability_at_least(7), - reason="FP16 tensor cores require compute capability >= 7.0", -) - - -def _have_fused() -> bool: - try: - import puzzle_sim_cuda_ext - return hasattr(puzzle_sim_cuda_ext, "FusedSqueezeNet") - except ImportError: # pragma: no cover - exercised via skip - return False - - -requires_fused = pytest.mark.skipif( - not _have_fused(), - reason="FusedSqueezeNet not available in the CUDA extension", -) - - -def _abs_err(a: torch.Tensor, b: torch.Tensor) -> float: - return (a - b).abs().max().item() - - -# --------------------------------------------------------------------------- -# Feature extraction agreement: fused backbone vs torchvision reference -# --------------------------------------------------------------------------- - -@requires_cuda -@requires_ext -@requires_fused -def test_fused_backbone_matches_reference_fp32(): - """When TF32 is disabled, fused features must match torchvision to ~1e-7.""" - from puzzle_sim_cuda import PuzzleSimCUDAFused - - prev = torch.backends.cudnn.allow_tf32 - torch.backends.cudnn.allow_tf32 = False - try: - refs = torch.rand(1, 3, 128, 128, device="cuda") - img = torch.rand(1, 3, 128, 128, device="cuda") - fused = PuzzleSimCUDAFused(refs, precision="fp32") - - # Compare directly against the wrapped torchvision SqueezeNet. - with torch.no_grad(): - scaled = fused._scaled_input(img, normalize=True) - ref_outs = fused._backbone(scaled) - - def _norm(x, eps=1e-8): - return x / (eps + x.pow(2).sum(dim=1, keepdim=True)).sqrt() - - feats = fused.compute_features(img, normalize=True, layers=(0, 1, 2, 3, 4, 5, 6)) - for k in range(7): - expected = _norm(ref_outs[k]) - got = feats[k] - err = _abs_err(expected, got) - assert err <= 1e-5, f"layer {k}: max err {err:.3e}" - finally: - torch.backends.cudnn.allow_tf32 = prev - - -# --------------------------------------------------------------------------- -# End-to-end agreement: fused vs kernel implementation -# --------------------------------------------------------------------------- - -@requires_cuda -@requires_ext -@requires_fused -@pytest.mark.parametrize("precision", [ - "fp32", - pytest.param("tf32", marks=_SKIP_TF32), - pytest.param("fp16", marks=_SKIP_FP16), -]) -@pytest.mark.parametrize("shape", [ - (4, 64), # tiny refs/img - (3, 96), - (8, 128), -]) -def test_fused_matches_kernel(precision, shape): - from puzzle_sim_cuda import PuzzleSimCUDA, PuzzleSimCUDAFused - - N, S = shape - refs = torch.rand(N, 3, S, S, device="cuda") - img = torch.rand(1, 3, S, S, device="cuda") - - kernel = PuzzleSimCUDA(refs, net_type="squeeze", precision=precision) - fused = PuzzleSimCUDAFused(refs, precision=precision) - with torch.no_grad(): - out_k = kernel(img) - out_f = fused(img) - - assert out_k.shape == out_f.shape - err = _abs_err(out_k, out_f) - # tf32/fp16 multiply mode-tolerance by 3 because three layers sum into the - # final map. fp32 mode is already measured against an empirical bound that - # absorbs the conv-algorithm difference; we keep it as-is. - atol = _TOLERANCE[precision] if precision == "fp32" else _TOLERANCE[precision] * 3 - assert err <= atol, ( - f"precision={precision}, shape={shape}: max abs err {err:.3e} > {atol:.0e}" - ) - - -@requires_cuda -@requires_ext -@requires_fused -def test_fused_handles_resize(): - from puzzle_sim_cuda import PuzzleSimCUDA, PuzzleSimCUDAFused - - refs = torch.rand(5, 3, 256, 192, device="cuda") - img = torch.rand(1, 3, 256, 192, device="cuda") - - kernel = PuzzleSimCUDA(refs, net_type="squeeze", resize=(128, 96), precision="fp32") - fused = PuzzleSimCUDAFused(refs, resize=(128, 96), precision="fp32") - with torch.no_grad(): - out_k = kernel(img) - out_f = fused(img) - - assert out_k.shape == out_f.shape == img.shape[-2:] - err = _abs_err(out_k, out_f) - assert err <= _TOLERANCE["fp32"], f"resize path max abs err {err:.3e}" - - -@requires_cuda -@requires_ext -@requires_fused -def test_fused_layer_subset(): - """Picking a non-default layer set must work end-to-end.""" - from puzzle_sim_cuda import PuzzleSimCUDAFused - - refs = torch.rand(3, 3, 96, 96, device="cuda") - img = torch.rand(1, 3, 96, 96, device="cuda") - fused = PuzzleSimCUDAFused(refs, precision="fp32") - - with torch.no_grad(): - out = fused(img, layers=(0, 1, 2), weights=(0.5, 0.3, 0.2)) - assert out.shape == img.shape[-2:] - assert torch.isfinite(out).all() - - -@requires_cuda -@requires_ext -@requires_fused -def test_fused_repeated_forwards_stable(): - """Two forwards on the same input must produce identical output.""" - from puzzle_sim_cuda import PuzzleSimCUDAFused - - refs = torch.rand(3, 3, 96, 96, device="cuda") - img = torch.rand(1, 3, 96, 96, device="cuda") - fused = PuzzleSimCUDAFused(refs, precision="fp32") - - with torch.no_grad(): - a = fused(img) - b = fused(img) - assert torch.equal(a, b), "Fused forward must be deterministic across calls" - - -@requires_cuda -@requires_ext -@requires_fused -@requires_demo_data("garden") -@pytest.mark.parametrize("precision", [ - "fp32", - pytest.param("tf32", marks=_SKIP_TF32), - pytest.param("fp16", marks=_SKIP_FP16), -]) -def test_fused_garden_matches_kernel(garden_data, precision): - """End-to-end agreement on real garden images, across all precision modes.""" - from puzzle_sim_cuda import PuzzleSimCUDA, PuzzleSimCUDAFused - - assert garden_data is not None - priors, tests, _ = garden_data - img = tests[0:1] - - kernel = PuzzleSimCUDA(priors, net_type="squeeze", resize=(256, 256), precision=precision) - fused = PuzzleSimCUDAFused(priors, resize=(256, 256), precision=precision) - with torch.no_grad(): - out_k = kernel(img) - out_f = fused(img) - - assert out_k.shape == out_f.shape - assert torch.isfinite(out_f).all() - err = _abs_err(out_k, out_f) - atol = _TOLERANCE[precision] if precision == "fp32" else _TOLERANCE[precision] * 3 - assert err <= atol, f"garden / {precision}: max abs err {err:.3e} > {atol:.0e}" - - -# --------------------------------------------------------------------------- -# Factory + fallback behaviour -# --------------------------------------------------------------------------- - -@requires_cuda -@requires_ext -@requires_fused -def test_factory_dispatches_to_fused_for_squeeze(): - from puzzle_sim_cuda import PuzzleSim, PuzzleSimCUDAFused, PuzzleSimCUDA - - refs = torch.rand(2, 3, 64, 64, device="cuda") - m_fused = PuzzleSim(refs, net_type="squeeze", implementation="fused") - assert isinstance(m_fused, PuzzleSimCUDAFused) - - m_kernel = PuzzleSim(refs, net_type="squeeze", implementation="kernel") - assert isinstance(m_kernel, PuzzleSimCUDA) - - -@requires_cuda -@requires_ext -@requires_fused -def test_factory_fused_falls_back_for_non_squeeze(): - """Fused path is squeeze-only for now; alex/vgg must silently fall back.""" - from puzzle_sim_cuda import PuzzleSim, PuzzleSimCUDA - - refs = torch.rand(2, 3, 64, 64, device="cuda") - for net in ("alex", "vgg"): - m = PuzzleSim(refs, net_type=net, implementation="fused") - assert isinstance(m, PuzzleSimCUDA), \ - f"Expected fallback to PuzzleSimCUDA for {net}, got {type(m).__name__}" - - -@requires_cuda -@requires_ext -@requires_fused -def test_invalid_precision_raises(): - from puzzle_sim_cuda import PuzzleSimCUDAFused - refs = torch.rand(2, 3, 64, 64, device="cuda") - with pytest.raises(ValueError): - PuzzleSimCUDAFused(refs, precision="bf16") diff --git a/puzzle_sim_cuda/tests/test_grad.py b/puzzle_sim_cuda/tests/test_grad.py deleted file mode 100644 index e02fe54..0000000 --- a/puzzle_sim_cuda/tests/test_grad.py +++ /dev/null @@ -1,248 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -"""Gradient / differentiable-loss tests for both PuzzleSim CUDA modes. - -PuzzleSim can be used as a perceptual loss on a *query image*: the backbone -weights and the reference distribution stay frozen, and gradients flow back to -the input. These tests verify that path end to end. - -What is covered: - -1. ``forward`` produces a graph (``requires_grad``) and ``backward`` populates a - finite, non-zero ``img.grad`` for both ``PuzzleSimCUDA`` (fp32/tf32/fp16) and - ``PuzzleSimCUDAFused``. -2. The fast inference path is unchanged: with no grad required (or under - ``torch.no_grad``) the output is detached and the custom kernels are used. -3. A finite-difference check: the analytic gradient matches a central - finite-difference estimate of the directional derivative (exact-FP32 cuDNN). -4. An Adam loop actually minimises a PuzzleSim-based loss. - -The tensor-core ``sim_max`` kernels have no backward, so whenever the query -carries grad the metric falls back to an exact FP32 ``sim_max``. That is why the -gradient tests do not need tensor-core hardware: they exercise the FP32 path -regardless of the model's nominal ``precision``. -""" - -from __future__ import annotations - -import contextlib - -import pytest -import torch - -from .conftest import requires_cuda, requires_ext, requires_demo_data - - -def _build(kind: str, refs: torch.Tensor, precision: str): - if kind == "kernel": - from puzzle_sim_cuda import PuzzleSimCUDA - - return PuzzleSimCUDA(refs, net_type="squeeze", precision=precision) - if kind == "fused": - from puzzle_sim_cuda import PuzzleSimCUDAFused - - return PuzzleSimCUDAFused(refs, precision=precision) - raise ValueError(kind) - - -@contextlib.contextmanager -def _exact_fp32_cudnn(): - """Force deterministic, non-TF32 cuDNN/cuBLAS so finite differences line up - with the analytic gradient (TF32 convs would add ~1e-3 noise).""" - prev_det = torch.backends.cudnn.deterministic - prev_cudnn_tf32 = torch.backends.cudnn.allow_tf32 - prev_mm_tf32 = torch.backends.cuda.matmul.allow_tf32 - torch.backends.cudnn.deterministic = True - torch.backends.cudnn.allow_tf32 = False - torch.backends.cuda.matmul.allow_tf32 = False - try: - yield - finally: - torch.backends.cudnn.deterministic = prev_det - torch.backends.cudnn.allow_tf32 = prev_cudnn_tf32 - torch.backends.cuda.matmul.allow_tf32 = prev_mm_tf32 - - -_KINDS_PRECISIONS = [ - ("kernel", "fp32"), - ("kernel", "tf32"), - ("kernel", "fp16"), - ("fused", "tf32"), -] - - -# --------------------------------------------------------------------------- -# 1. The output is differentiable w.r.t. the query image -# --------------------------------------------------------------------------- - -@requires_cuda -@requires_ext -@pytest.mark.parametrize("kind,precision", _KINDS_PRECISIONS) -def test_backward_populates_query_grad(kind, precision): - refs = torch.rand(4, 3, 64, 64, device="cuda") - model = _build(kind, refs, precision) - - img = torch.rand(1, 3, 64, 64, device="cuda", requires_grad=True) - out = model(img) - assert out.requires_grad, f"{kind}/{precision}: output is detached" - - loss = -out.mean() - loss.backward() - - assert img.grad is not None, f"{kind}/{precision}: no grad produced" - assert torch.isfinite(img.grad).all(), f"{kind}/{precision}: non-finite grad" - assert img.grad.abs().max() > 0, f"{kind}/{precision}: grad is identically zero" - - -@requires_cuda -@requires_ext -@pytest.mark.parametrize("kind,precision", _KINDS_PRECISIONS) -def test_references_and_weights_stay_frozen(kind, precision): - """Only the query image should accumulate grad; the model is frozen.""" - refs = torch.rand(3, 3, 64, 64, device="cuda") - model = _build(kind, refs, precision) - - img = torch.rand(1, 3, 64, 64, device="cuda", requires_grad=True) - (-model(img).mean()).backward() - - trainable = [p for p in model.parameters() if p.requires_grad] - assert not trainable, f"{kind}/{precision}: backbone params are not frozen" - - -# --------------------------------------------------------------------------- -# 2. The fast inference path is untouched -# --------------------------------------------------------------------------- - -@requires_cuda -@requires_ext -@pytest.mark.parametrize("kind,precision", _KINDS_PRECISIONS) -def test_inference_output_is_detached(kind, precision): - refs = torch.rand(3, 3, 64, 64, device="cuda") - model = _build(kind, refs, precision) - - img = torch.rand(1, 3, 64, 64, device="cuda") # no requires_grad - out = model(img) - assert not out.requires_grad, f"{kind}/{precision}: inference output carries grad" - - -@requires_cuda -@requires_ext -@pytest.mark.parametrize("kind,precision", _KINDS_PRECISIONS) -def test_no_grad_context_uses_fast_path(kind, precision): - """Even a leaf that requires grad is detached under ``torch.no_grad``.""" - refs = torch.rand(3, 3, 64, 64, device="cuda") - model = _build(kind, refs, precision) - - img = torch.rand(1, 3, 64, 64, device="cuda", requires_grad=True) - with torch.no_grad(): - out = model(img) - assert not out.requires_grad, f"{kind}/{precision}: grad recorded under no_grad" - - -# --------------------------------------------------------------------------- -# 3. Finite-difference check of the analytic gradient -# --------------------------------------------------------------------------- - -@requires_cuda -@requires_ext -@pytest.mark.parametrize("kind", ["kernel", "fused"]) -def test_finite_difference_directional(kind): - """Central finite difference of the directional derivative along the - gradient direction must match the analytic gradient norm. - - Using ``v = g/||g||`` gives the strongest directional signal (best SNR for - a finite-difference probe through a deep network).""" - torch.manual_seed(0) - refs = torch.rand(2, 3, 32, 32, device="cuda") - model = _build(kind, refs, "fp32") - - def loss_value(x: torch.Tensor) -> float: - # Fresh leaf -> differentiable (PyTorch-op) path, matching the analytic - # forward exactly. We only need the scalar value here. - xr = x.detach().requires_grad_(True) - with torch.enable_grad(): - return float(model(xr, normalize=True).sum().item()) - - with _exact_fp32_cudnn(): - base = torch.rand(1, 3, 32, 32, device="cuda") - - img = base.detach().requires_grad_(True) - with torch.enable_grad(): - loss = model(img, normalize=True).sum() - loss.backward() - g = img.grad - assert g is not None - gnorm = g.norm() - assert gnorm > 1e-4 - - v = g / gnorm - eps = 2e-3 - f_plus = loss_value(base + eps * v) - f_minus = loss_value(base - eps * v) - dd_fd = (f_plus - f_minus) / (2 * eps) - dd_analytic = float(gnorm.item()) # (g . v) == ||g|| - - rel = abs(dd_fd - dd_analytic) / max(abs(dd_analytic), 1e-6) - assert rel < 5e-2, ( - f"{kind}: directional FD {dd_fd:.4f} vs analytic {dd_analytic:.4f} " - f"(rel err {rel:.3%})" - ) - - -# --------------------------------------------------------------------------- -# 4. PuzzleSim is minimisable as a loss -# --------------------------------------------------------------------------- - -@requires_cuda -@requires_ext -@pytest.mark.parametrize("kind,precision", _KINDS_PRECISIONS) -def test_adam_reduces_loss(kind, precision): - """Optimising an image to *increase* similarity reduces ``-sim.mean()``.""" - refs = torch.rand(4, 3, 64, 64, device="cuda") - model = _build(kind, refs, precision) - - img = torch.rand(1, 3, 64, 64, device="cuda", requires_grad=True) - opt = torch.optim.Adam([img], lr=5e-2) - - losses = [] - for _ in range(40): - opt.zero_grad() - loss = -model(img).mean() - loss.backward() - opt.step() - with torch.no_grad(): - img.clamp_(0.0, 1.0) - losses.append(loss.item()) - - assert all(torch.isfinite(torch.tensor(losses))) - # Final loss is clearly below the start, and the tail is below the head. - assert losses[-1] < losses[0] - 1e-3, f"{kind}/{precision}: no progress {losses[0]:.4f}->{losses[-1]:.4f}" - assert sum(losses[-5:]) / 5 < sum(losses[:5]) / 5, f"{kind}/{precision}: not trending down" - - -@requires_cuda -@requires_ext -@requires_demo_data("garden") -def test_adam_reduces_loss_real_data(garden_data): - """Same optimisation sanity check on a real reference distribution.""" - from puzzle_sim_cuda import PuzzleSimCUDA - - assert garden_data is not None - priors, tests, _ = garden_data - model = PuzzleSimCUDA(priors, net_type="squeeze", resize=(128, 128), precision="fp32") - - img = tests[0:1].clone().detach().requires_grad_(True) - opt = torch.optim.Adam([img], lr=2e-2) - - first = last = None - for step in range(25): - opt.zero_grad() - loss = -model(img).mean() - loss.backward() - opt.step() - with torch.no_grad(): - img.clamp_(0.0, 1.0) - if step == 0: - first = loss.item() - last = loss.item() - - assert last < first, f"loss did not decrease: {first:.4f} -> {last:.4f}" diff --git a/puzzle_sim_cuda/tests/test_kernels.py b/puzzle_sim_cuda/tests/test_kernels.py deleted file mode 100644 index 322a28b..0000000 --- a/puzzle_sim_cuda/tests/test_kernels.py +++ /dev/null @@ -1,152 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -"""Per-kernel correctness tests. - -Each kernel is compared against an obvious PyTorch reference implementation -of the same operation. We use float32 throughout, so the tolerance is set just -above the rounding floor for the corresponding op. -""" - -from __future__ import annotations - -import pytest -import torch - -from .conftest import requires_cuda, requires_ext - - -def _normalize_ref(x: torch.Tensor, eps: float = 1e-8) -> torch.Tensor: - return x / torch.sqrt(eps + x.pow(2).sum(dim=1, keepdim=True)) - - -# --------------------------------------------------------------------------- -# normalize_features -# --------------------------------------------------------------------------- - -@requires_cuda -@requires_ext -@pytest.mark.parametrize("shape", [ - (1, 64, 16, 16), - (4, 128, 32, 32), - (8, 256, 8, 8), - (1, 384, 64, 64), - (3, 512, 7, 9), # non-square spatial -]) -def test_normalize_features_matches_pytorch(shape): - import puzzle_sim_cuda_ext as ext - - x = torch.randn(*shape, device="cuda", dtype=torch.float32) - ref = _normalize_ref(x) - out = ext.normalize_features(x.contiguous(), 1e-8) - - assert out.shape == ref.shape - assert torch.allclose(out, ref, atol=1e-6, rtol=1e-5) - - -@requires_cuda -@requires_ext -def test_normalize_features_unit_norm(): - """L2 norm along channels must be ~1 after normalization.""" - import puzzle_sim_cuda_ext as ext - x = torch.randn(2, 64, 16, 16, device="cuda", dtype=torch.float32) - out = ext.normalize_features(x.contiguous(), 1e-8) - norms = out.pow(2).sum(dim=1).sqrt() - assert torch.allclose(norms, torch.ones_like(norms), atol=1e-5) - - -# --------------------------------------------------------------------------- -# pack_reference -# --------------------------------------------------------------------------- - -@requires_cuda -@requires_ext -@pytest.mark.parametrize("shape", [(4, 32, 6, 6), (1, 128, 8, 8), (10, 256, 16, 16)]) -def test_pack_reference_layout(shape): - import puzzle_sim_cuda_ext as ext - refs = torch.randn(*shape, device="cuda", dtype=torch.float32) - packed = ext.pack_reference(refs.contiguous()) - N, C, H, W = shape - assert packed.shape == (C, N * H * W) - # Equivalent to transpose+flatten in torch. - expected = refs.transpose(0, 1).contiguous().reshape(C, N * H * W) - assert torch.equal(packed, expected) - - -# --------------------------------------------------------------------------- -# _sim_max (Python-side, cuBLAS-backed) -# --------------------------------------------------------------------------- - -@requires_cuda -@pytest.mark.parametrize("N,C,H,W", [ - (1, 32, 8, 8), - (5, 64, 8, 8), - (10, 128, 16, 16), - (1, 256, 32, 32), - (3, 256, 13, 11), # awkward spatial sizes - (8, 512, 4, 4), - (36, 256, 52, 78), # ~garden layer 2; large enough that chunking kicks in -]) -def test_sim_max_matches_matmul(N, C, H, W): - from puzzle_sim_cuda.puzzle_sim_cuda import _sim_max, _pack_reference - - refs = torch.randn(N, C, H, W, device="cuda", dtype=torch.float32) - q = torch.randn(C, H, W, device="cuda", dtype=torch.float32) - - refs = refs / torch.sqrt(1e-8 + refs.pow(2).sum(dim=1, keepdim=True)) - qn = q / torch.sqrt(1e-8 + q.pow(2).sum(dim=0, keepdim=True)) - - packed = _pack_reference(refs.contiguous()) - out = _sim_max(qn, packed, (H, W)) - - # PyTorch reference: full GEMM + row-wise max. - qp = qn.reshape(C, H * W).contiguous() - refs_flat = refs.transpose(0, 1).contiguous().reshape(C, N * H * W) - scores = qp.T @ refs_flat - expected = scores.max(dim=1).values.reshape(H, W) - - assert out.shape == expected.shape - assert torch.allclose(out, expected, atol=1e-5, rtol=1e-5) - - -@requires_cuda -def test_sim_max_self_similarity_is_one(): - """When the query is one of the references, the per-pixel max must be 1 - (within float epsilon) because each query pixel matches itself exactly.""" - from puzzle_sim_cuda.puzzle_sim_cuda import _sim_max, _pack_reference - - N, C, H, W = 3, 64, 8, 8 - refs = torch.randn(N, C, H, W, device="cuda", dtype=torch.float32) - refs = refs / torch.sqrt(1e-8 + refs.pow(2).sum(dim=1, keepdim=True)) - packed = _pack_reference(refs.contiguous()) - - out = _sim_max(refs[0], packed, (H, W)) - - assert torch.allclose(out, torch.ones_like(out), atol=1e-5) - - -# --------------------------------------------------------------------------- -# bilinear_upsample -# --------------------------------------------------------------------------- - -@requires_cuda -@requires_ext -@pytest.mark.parametrize("in_hw,out_hw,align", [ - ((8, 8), (64, 64), True), - ((16, 16), (128, 128), True), - ((6, 9), (32, 48), True), - ((8, 8), (33, 41), True), - ((8, 8), (64, 64), False), -]) -def test_bilinear_upsample_matches_torch(in_hw, out_hw, align): - import puzzle_sim_cuda_ext as ext - - x = torch.randn(*in_hw, device="cuda", dtype=torch.float32) - out = ext.bilinear_upsample(x.contiguous(), list(out_hw), align) - expected = torch.nn.functional.interpolate( - x.unsqueeze(0).unsqueeze(0), - size=out_hw, - mode="bilinear", - align_corners=align, - ).squeeze(0).squeeze(0) - - assert out.shape == expected.shape - assert torch.allclose(out, expected, atol=1e-5, rtol=1e-5) diff --git a/puzzle_sim_cuda/tests/test_puzzlesim.py b/puzzle_sim_cuda/tests/test_puzzlesim.py deleted file mode 100644 index 643d223..0000000 --- a/puzzle_sim_cuda/tests/test_puzzlesim.py +++ /dev/null @@ -1,138 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -"""End-to-end correctness tests of ``PuzzleSimCUDA`` against the reference -PyTorch implementation in ``puzzle_sim.PuzzleSim``. - -These tests pin ``precision="fp32"`` so any drift is purely from reduction- -order changes in our matmul + max chunking (not from TF32 / FP16 rounding). -The relaxed-precision paths are exercised in :mod:`test_tensor_cores`. -""" - -from __future__ import annotations - -import pytest -import torch - -from .conftest import requires_cuda, requires_ext - - -def _make_inputs(num_refs: int, hw: tuple[int, int]) -> tuple[torch.Tensor, torch.Tensor]: - refs = torch.rand(num_refs, 3, *hw, device="cuda") - img = torch.rand(1, 3, *hw, device="cuda") - return refs, img - - -def _run_ref(refs: torch.Tensor, img: torch.Tensor, **kwargs) -> torch.Tensor: - from puzzle_sim import PuzzleSim as RefPuzzleSim - model = RefPuzzleSim(refs, **kwargs).to(refs.device).eval() - with torch.no_grad(): - return model(img) - - -def _run_cuda(refs: torch.Tensor, img: torch.Tensor, **kwargs) -> torch.Tensor: - from puzzle_sim_cuda import PuzzleSimCUDA - kwargs.setdefault("precision", "fp32") - model = PuzzleSimCUDA(refs, **kwargs) - with torch.no_grad(): - return model(img) - - -@requires_cuda -@requires_ext -@pytest.mark.parametrize("net_type", ["squeeze", "alex", "vgg"]) -def test_matches_reference_on_random_inputs(net_type): - """End-to-end agreement across the three supported backbones.""" - refs, img = _make_inputs(num_refs=5, hw=(96, 96)) - ref_out = _run_ref(refs, img, net_type=net_type) - cuda_out = _run_cuda(refs, img, net_type=net_type) - - assert ref_out.shape == cuda_out.shape - rel = (ref_out - cuda_out).abs().max() / ref_out.abs().max().clamp_min(1e-9) - assert rel.item() < 1e-4, ( - f"net={net_type} relative error too high: {rel.item():.3e}" - ) - - -@requires_cuda -@requires_ext -@pytest.mark.parametrize("hw", [(64, 64), (96, 128), (128, 96), (160, 160)]) -def test_matches_reference_across_input_shapes(hw): - refs, img = _make_inputs(num_refs=4, hw=hw) - ref_out = _run_ref(refs, img, net_type="squeeze") - cuda_out = _run_cuda(refs, img, net_type="squeeze") - assert ref_out.shape == (hw[0], hw[1]) - assert cuda_out.shape == (hw[0], hw[1]) - rel = (ref_out - cuda_out).abs().max() / ref_out.abs().max().clamp_min(1e-9) - assert rel.item() < 1e-4 - - -@requires_cuda -@requires_ext -def test_matches_reference_with_resize(): - refs, img = _make_inputs(num_refs=5, hw=(160, 160)) - ref_out = _run_ref(refs, img, net_type="squeeze", resize=(96, 96)) - cuda_out = _run_cuda(refs, img, net_type="squeeze", resize=(96, 96)) - assert ref_out.shape == cuda_out.shape - rel = (ref_out - cuda_out).abs().max() / ref_out.abs().max().clamp_min(1e-9) - assert rel.item() < 1e-4 - - -@requires_cuda -@requires_ext -def test_self_image_is_high_similarity(): - """An image that is itself one of the references should score very high.""" - refs, _ = _make_inputs(num_refs=4, hw=(96, 96)) - img = refs[0:1].clone() - out = _run_cuda(refs, img, net_type="squeeze") - # The default weights sum to 1.0, so a "perfect" match would give ~1.0. - assert out.mean().item() > 0.95 - - -@requires_cuda -@requires_ext -def test_caches_reference_features_across_calls(): - """Second forward pass should reuse the packed reference cache.""" - from puzzle_sim_cuda import PuzzleSimCUDA - - refs, img = _make_inputs(num_refs=4, hw=(96, 96)) - model = PuzzleSimCUDA(refs, net_type="squeeze", precision="fp32") - with torch.no_grad(): - out1 = model(img) - # Mutate the underlying reference tensor. The cached features must - # still be used (we intentionally do not invalidate the cache to - # match the reference implementation's behaviour). - refs.zero_() - out2 = model(img) - assert torch.allclose(out1, out2) - - -@requires_cuda -@requires_ext -def test_reduction_modes(): - """Mean reduction must equal sum reduction divided by the layer count.""" - refs, img = _make_inputs(num_refs=3, hw=(96, 96)) - from puzzle_sim_cuda import PuzzleSimCUDA - model = PuzzleSimCUDA(refs, net_type="squeeze", precision="fp32") - with torch.no_grad(): - s = model(img, reduction="sum") - m = model(img, reduction="mean") - # With default layers=(2,3,4), mean = sum / 3. - assert torch.allclose(m, s / 3.0, atol=1e-6, rtol=1e-5) - - -@requires_cuda -@requires_ext -def test_weights_validation(): - refs, img = _make_inputs(num_refs=2, hw=(96, 96)) - from puzzle_sim_cuda import PuzzleSimCUDA - model = PuzzleSimCUDA(refs, net_type="squeeze", precision="fp32") - with pytest.raises(ValueError): - model(img, layers=(2, 3, 4), weights=(0.5, 0.5)) - - -@requires_cuda -@requires_ext -def test_invalid_net_type_raises(): - refs, _ = _make_inputs(num_refs=2, hw=(96, 96)) - from puzzle_sim_cuda import PuzzleSimCUDA - with pytest.raises(ValueError): - PuzzleSimCUDA(refs, net_type="not-a-real-net") diff --git a/puzzle_sim_cuda/tests/test_real_data.py b/puzzle_sim_cuda/tests/test_real_data.py deleted file mode 100644 index 37c16e2..0000000 --- a/puzzle_sim_cuda/tests/test_real_data.py +++ /dev/null @@ -1,148 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -"""End-to-end correctness tests on real image data. - -These tests exercise ``PuzzleSimCUDA`` against ``puzzle_sim.PuzzleSim`` on the -garden dataset (36 priors + 4 test images, all 628x416 RGB). - -They are slower than the random-tensor tests in :mod:`test_puzzlesim` so we -keep the matrix small (one or two test images, one or two configurations). -The point of these tests is to catch regressions that only surface on real -data - e.g. denormals, NaNs from edge pixels, or layout assumptions that -break on non-square inputs. -""" - -from __future__ import annotations - -import pytest -import torch - -from .conftest import requires_cuda, requires_ext, requires_demo_data - - -def _relative_error(a: torch.Tensor, b: torch.Tensor) -> float: - return ( - (a - b).abs().max() / a.abs().max().clamp_min(1e-9) - ).item() - - -@requires_cuda -@requires_ext -@requires_demo_data("garden") -@pytest.mark.parametrize("resize", [None, (256, 256), (128, 128)]) -def test_garden_matches_reference(garden_data, resize): - """Full PuzzleSim on the garden dataset must match the PyTorch reference. - - We use the first test image only (the others would just multiply runtime - by 4 without exercising any new code path). - """ - from puzzle_sim import PuzzleSim as RefPuzzleSim - from puzzle_sim_cuda import PuzzleSimCUDA - - assert garden_data is not None - priors, tests, _ = garden_data - img = tests[0:1] - - ref_model = RefPuzzleSim(priors, net_type="squeeze", resize=resize).to(priors.device).eval() - cuda_model = PuzzleSimCUDA(priors, net_type="squeeze", resize=resize, precision="fp32") - - with torch.no_grad(): - ref_out = ref_model(img) - cuda_out = cuda_model(img) - - assert ref_out.shape == cuda_out.shape == img.shape[-2:] - assert torch.isfinite(cuda_out).all(), "CUDA output contains NaN/Inf" - rel = _relative_error(ref_out, cuda_out) - assert rel < 1e-4, f"resize={resize!r}: relative error too high: {rel:.3e}" - - -@requires_cuda -@requires_ext -@requires_demo_data("garden") -def test_garden_all_test_images(garden_data): - """Every test image in the dataset should match the reference.""" - from puzzle_sim import PuzzleSim as RefPuzzleSim - from puzzle_sim_cuda import PuzzleSimCUDA - - assert garden_data is not None - priors, tests, names = garden_data - - ref_model = RefPuzzleSim(priors, net_type="squeeze", resize=(256, 256)).to(priors.device).eval() - cuda_model = PuzzleSimCUDA(priors, net_type="squeeze", resize=(256, 256), precision="fp32") - - for i, name in enumerate(names): - img = tests[i:i + 1] - with torch.no_grad(): - ref_out = ref_model(img) - cuda_out = cuda_model(img) - rel = _relative_error(ref_out, cuda_out) - assert rel < 1e-4, f"{name}: relative error {rel:.3e}" - - -@requires_cuda -@requires_ext -@requires_demo_data("garden") -@pytest.mark.parametrize("net_type", ["squeeze", "alex", "vgg"]) -def test_garden_all_backbones(garden_data, net_type): - """All three backbones must work on the real-data path.""" - from puzzle_sim import PuzzleSim as RefPuzzleSim - from puzzle_sim_cuda import PuzzleSimCUDA - - assert garden_data is not None - priors, tests, _ = garden_data - img = tests[0:1] - - ref_model = RefPuzzleSim(priors, net_type=net_type, resize=(256, 256)).to(priors.device).eval() - cuda_model = PuzzleSimCUDA(priors, net_type=net_type, resize=(256, 256), precision="fp32") - - with torch.no_grad(): - ref_out = ref_model(img) - cuda_out = cuda_model(img) - - rel = _relative_error(ref_out, cuda_out) - assert rel < 1e-4, f"net={net_type}: relative error {rel:.3e}" - - -@requires_cuda -@requires_ext -@requires_demo_data("garden") -def test_garden_output_is_a_valid_similarity_map(garden_data): - """Sanity-check the metric values themselves. - - With default ``weights=(0.67, 0.2, 0.13)`` (sum == 1.0) and cosine - similarities in [-1, 1], the per-pixel score is bounded in [-1, 1]. - On natural images we expect to be solidly in [0, 1]. - """ - from puzzle_sim_cuda import PuzzleSimCUDA - - assert garden_data is not None - priors, tests, _ = garden_data - - cuda_model = PuzzleSimCUDA(priors, net_type="squeeze", resize=(256, 256)) - with torch.no_grad(): - out = cuda_model(tests[0:1]) - - assert torch.isfinite(out).all() - assert out.min().item() >= -1.0 - assert out.max().item() <= 1.0 + 1e-5 - assert out.mean().item() > 0.5, "expected high similarity on natural data" - - -@requires_cuda -@requires_ext -@requires_demo_data("garden") -def test_garden_self_image_high_similarity(garden_data): - """An image that is itself one of the priors should produce a very high - average similarity. This catches algorithmic mistakes that would otherwise - only show up as small numerical disagreement with the reference.""" - from puzzle_sim_cuda import PuzzleSimCUDA - - assert garden_data is not None - priors, _, _ = garden_data - - cuda_model = PuzzleSimCUDA(priors, net_type="squeeze", resize=(256, 256)) - with torch.no_grad(): - out = cuda_model(priors[0:1]) - - assert out.mean().item() > 0.95, ( - f"self-image average similarity should be ~1, got {out.mean().item():.3f}" - ) diff --git a/puzzle_sim_cuda/tests/test_tensor_cores.py b/puzzle_sim_cuda/tests/test_tensor_cores.py deleted file mode 100644 index cb67522..0000000 --- a/puzzle_sim_cuda/tests/test_tensor_cores.py +++ /dev/null @@ -1,216 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -"""Correctness tests for the tensor-core sim_max kernel. - -These verify two things, mode by mode: - -1. The kernel-level wrapper ``_sim_max(..., precision=p)`` agrees with the - reference ``(Q.T @ R).max(dim=1)`` within the tolerance expected for the - precision mode. -2. The full ``PuzzleSimCUDA`` model with ``precision={'tf32','fp16'}`` produces - the same output as ``precision='fp32'`` within the same tolerance. - -Tolerances: - -* fp32: atol=1e-5 (rounding floor) -* tf32: atol=1e-3 (10-bit mantissa with FP32 accumulator) -* fp16: atol=5e-3 (5-bit exponent + 10-bit mantissa with FP32 accumulator) -""" - -from __future__ import annotations - -import pytest -import torch - -from .conftest import requires_cuda, requires_ext, requires_demo_data - - -_TOLERANCE = {"fp32": 1e-5, "tf32": 1e-3, "fp16": 5e-3} - - -def _device_capability_at_least(major: int, minor: int = 0) -> bool: - if not torch.cuda.is_available(): - return False - cap = torch.cuda.get_device_capability() - return cap >= (major, minor) - - -_SKIP_TF32 = pytest.mark.skipif( - not _device_capability_at_least(8), - reason="TF32 tensor cores require compute capability >= 8.0", -) -_SKIP_FP16 = pytest.mark.skipif( - not _device_capability_at_least(7), - reason="FP16 tensor cores require compute capability >= 7.0", -) - - -def _reference_sim_max(Q: torch.Tensor, R: torch.Tensor) -> torch.Tensor: - return (Q.T @ R).max(dim=1).values - - -def _refs_for_precision(packed_fp32: torch.Tensor, precision: str) -> torch.Tensor: - if precision == "fp16": - return packed_fp32.half().contiguous() - return packed_fp32 - - -# --------------------------------------------------------------------------- -# Kernel-level: _sim_max in each mode -# --------------------------------------------------------------------------- - -@requires_cuda -@requires_ext -@pytest.mark.parametrize("precision", ["fp32", - pytest.param("tf32", marks=_SKIP_TF32), - pytest.param("fp16", marks=_SKIP_FP16)]) -@pytest.mark.parametrize("N,C,H,W", [ - (1, 32, 8, 8), # small - (10, 128, 16, 16), # mid - (1, 256, 32, 32), # bigger qHW - (3, 256, 13, 11), # non-power-of-two - (8, 512, 4, 4), - (36, 256, 52, 78), # garden-layer-2 scale -]) -def test_sim_max_matches_matmul_for_each_precision(precision, N, C, H, W): - from puzzle_sim_cuda.puzzle_sim_cuda import _sim_max, _pack_reference - - refs = torch.randn(N, C, H, W, device="cuda", dtype=torch.float32) - q = torch.randn(C, H, W, device="cuda", dtype=torch.float32) - refs = refs / torch.sqrt(1e-8 + refs.pow(2).sum(dim=1, keepdim=True)) - qn = q / torch.sqrt(1e-8 + q.pow(2).sum(dim=0, keepdim=True)) - - packed = _pack_reference(refs.contiguous()) - refs_for_p = _refs_for_precision(packed, precision) - - out = _sim_max(qn, refs_for_p, (H, W), precision=precision) - - qp = qn.reshape(C, H * W).contiguous() - refs_flat = refs.transpose(0, 1).contiguous().reshape(C, N * H * W) - expected = _reference_sim_max(qp, refs_flat).reshape(H, W) - - atol = _TOLERANCE[precision] - max_err = (out - expected).abs().max().item() - assert max_err <= atol, ( - f"precision={precision}: max_err={max_err:.3e} exceeds tolerance {atol:.0e}" - ) - - -@requires_cuda -@requires_ext -@_SKIP_TF32 -def test_sim_max_tf32_self_similarity_is_one(): - """When the query is a ref, the per-pixel max must be ~1 even for tf32.""" - from puzzle_sim_cuda.puzzle_sim_cuda import _sim_max, _pack_reference - - N, C, H, W = 3, 64, 8, 8 - refs = torch.randn(N, C, H, W, device="cuda", dtype=torch.float32) - refs = refs / torch.sqrt(1e-8 + refs.pow(2).sum(dim=1, keepdim=True)) - packed = _pack_reference(refs.contiguous()) - - out = _sim_max(refs[0], packed, (H, W), precision="tf32") - assert torch.allclose(out, torch.ones_like(out), atol=_TOLERANCE["tf32"]) - - -@requires_cuda -@requires_ext -@_SKIP_FP16 -def test_sim_max_fp16_self_similarity_is_one(): - from puzzle_sim_cuda.puzzle_sim_cuda import _sim_max, _pack_reference - - N, C, H, W = 3, 64, 8, 8 - refs = torch.randn(N, C, H, W, device="cuda", dtype=torch.float32) - refs = refs / torch.sqrt(1e-8 + refs.pow(2).sum(dim=1, keepdim=True)) - packed = _pack_reference(refs.contiguous()).half().contiguous() - - out = _sim_max(refs[0], packed, (H, W), precision="fp16") - assert torch.allclose(out, torch.ones_like(out), atol=_TOLERANCE["fp16"]) - - -# --------------------------------------------------------------------------- -# End-to-end: PuzzleSimCUDA in each mode against fp32 baseline -# --------------------------------------------------------------------------- - -def _abs_err(a: torch.Tensor, b: torch.Tensor) -> float: - return (a - b).abs().max().item() - - -@requires_cuda -@requires_ext -@pytest.mark.parametrize("precision", - [pytest.param("tf32", marks=_SKIP_TF32), - pytest.param("fp16", marks=_SKIP_FP16)]) -def test_puzzlesim_matches_fp32_baseline(precision): - """End-to-end ``PuzzleSimCUDA`` agreement between fp32 and {tf32, fp16}.""" - from puzzle_sim_cuda import PuzzleSimCUDA - - refs = torch.rand(4, 3, 96, 96, device="cuda") - img = torch.rand(1, 3, 96, 96, device="cuda") - - baseline = PuzzleSimCUDA(refs, net_type="squeeze", precision="fp32") - model = PuzzleSimCUDA(refs, net_type="squeeze", precision=precision) - with torch.no_grad(): - out_fp32 = baseline(img) - out_tc = model(img) - - err = _abs_err(out_fp32, out_tc) - # Relax the tolerance a little here vs the kernel-level test; the metric - # sums three layers (each gets to drift by ~atol/3) and then bilinearly - # upsamples, which doesn't add error but slightly smears it. - atol = _TOLERANCE[precision] * 3 - assert err <= atol, f"precision={precision}: max abs err {err:.3e} > {atol:.0e}" - - -@requires_cuda -@requires_ext -@requires_demo_data("garden") -@pytest.mark.parametrize("precision", - [pytest.param("tf32", marks=_SKIP_TF32), - pytest.param("fp16", marks=_SKIP_FP16)]) -def test_puzzlesim_garden_matches_fp32_baseline(garden_data, precision): - """Same end-to-end agreement test on real images at the garden scale.""" - from puzzle_sim_cuda import PuzzleSimCUDA - - assert garden_data is not None - priors, tests, _ = garden_data - img = tests[0:1] - - baseline = PuzzleSimCUDA(priors, net_type="squeeze", resize=(256, 256), precision="fp32") - model = PuzzleSimCUDA(priors, net_type="squeeze", resize=(256, 256), precision=precision) - with torch.no_grad(): - out_fp32 = baseline(img) - out_tc = model(img) - - err = _abs_err(out_fp32, out_tc) - atol = _TOLERANCE[precision] * 3 - assert torch.isfinite(out_tc).all() - assert err <= atol, f"precision={precision}: max abs err {err:.3e} > {atol:.0e}" - - -# --------------------------------------------------------------------------- -# Behaviour guarantees: graceful fallback / explicit dispatch -# --------------------------------------------------------------------------- - -@requires_cuda -@requires_ext -def test_invalid_precision_raises(): - from puzzle_sim_cuda import PuzzleSimCUDA - refs = torch.rand(2, 3, 64, 64, device="cuda") - with pytest.raises(ValueError): - PuzzleSimCUDA(refs, net_type="squeeze", precision="bf16") - - -@requires_cuda -@requires_ext -@_SKIP_FP16 -def test_fp16_uses_fp16_cached_refs(): - """Calling forward with precision='fp16' must cache an FP16 copy of refs.""" - from puzzle_sim_cuda import PuzzleSimCUDA - - refs = torch.rand(3, 3, 64, 64, device="cuda") - img = torch.rand(1, 3, 64, 64, device="cuda") - model = PuzzleSimCUDA(refs, net_type="squeeze", precision="fp16") - with torch.no_grad(): - _ = model(img) - assert len(model._packed_refs_fp16) >= 1 - for v in model._packed_refs_fp16.values(): - assert v.dtype == torch.float16 diff --git a/pyproject.toml b/pyproject.toml index 389fc8f..3521ac8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -16,7 +16,8 @@ maintainers = [ description = "Implementation of PuzzleSim, a cross-refence image similarity metric designed for artifact detection in novel view synthesis methods." readme = "README.md" requires-python = ">=3.8" -license = { file = "LICENSE.md" } +license = "MIT" +license-files = ["LICENSE.md"] keywords = ["puzzle similarity", "similarity", "no reference", "cross reference", "image metric"] classifiers = [ "Development Status :: 5 - Production/Stable", @@ -42,6 +43,9 @@ Issues = "https://github.com/nihermann/PuzzleSim/issues" where = ["src"] include = ["puzzle_sim*"] +[tool.setuptools.package-data] +puzzle_sim = ["py.typed", "cuda_ext/*.cpp", "cuda_ext/*.cu"] + [tool.setuptools.dynamic] dependencies = { file = ["requirements.txt"] } optional-dependencies = { dev = { file = ["requirements-dev.txt"] } } diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..6a5f790 --- /dev/null +++ b/setup.py @@ -0,0 +1,66 @@ +from __future__ import annotations + +import os +from typing import Any + +from setuptools import setup + + +def _truthy_env(name: str) -> bool: + return os.environ.get(name, "").strip().lower() in {"1", "true", "yes", "on"} + + +def _detected_arch_list() -> list[str]: + env = os.environ.get("TORCH_CUDA_ARCH_LIST") + if env: + return [item.strip() for item in env.split(";") if item.strip()] + + import torch + + if torch.cuda.is_available(): + major, minor = torch.cuda.get_device_capability() + return [f"{major}.{minor}"] + return ["7.0", "7.5", "8.0", "8.6", "8.9", "9.0"] + + +def _cuda_build_kwargs() -> dict[str, Any]: + if not _truthy_env("PUZZLE_SIM_BUILD_CUDA"): + return {} + + try: + import torch # noqa: F401 + from torch.utils.cpp_extension import BuildExtension, CUDAExtension + except ImportError as exc: # pragma: no cover - build-environment dependent + raise RuntimeError( + "PUZZLE_SIM_BUILD_CUDA=1 requires torch to be installed in the build environment. " + "Use pip build isolation off for CUDA wheel builds." + ) from exc + + os.environ.setdefault("TORCH_CUDA_ARCH_LIST", ";".join(_detected_arch_list())) + + ext_modules = [ + CUDAExtension( + name="puzzle_sim._cuda_ext", + sources=[ + "src/puzzle_sim/cuda_ext/puzzle_sim_cuda.cpp", + "src/puzzle_sim/cuda_ext/kernels.cu", + ], + extra_compile_args={ + "cxx": ["/O2"] if os.name == "nt" else ["-O3"], + "nvcc": [ + "-O3", + "--use_fast_math", + "--expt-relaxed-constexpr", + "-allow-unsupported-compiler", + ], + }, + ) + ] + return { + "ext_modules": ext_modules, + "cmdclass": {"build_ext": BuildExtension}, + "zip_safe": False, + } + + +setup(**_cuda_build_kwargs()) diff --git a/src/puzzle_sim/__init__.py b/src/puzzle_sim/__init__.py index 363e21c..13670ca 100644 --- a/src/puzzle_sim/__init__.py +++ b/src/puzzle_sim/__init__.py @@ -1,14 +1,33 @@ -from typing import List, Optional, Tuple, Literal, Sequence, Union +from typing import Dict, List, Optional, Tuple, Literal, Sequence, Union import torch from torch import Tensor, nn import torch.nn.functional as F +from . import cuda_backend from puzzle_sim.adapters import FeatureExtractor, get_feature_extractor, NetType, Dinov3Type, VGGAlexSqueezeType from puzzle_sim.helpers import upsample, resize_tensor -def find_best_matching_piece(refs: Tensor, img: Tensor, *, stride: Optional[int] = 4, mem_save: bool = True) -> Tensor: +def cuda_extension_available() -> bool: + """Return True when the optional compiled CUDA extension is importable.""" + return cuda_backend.is_available() + + +def get_cuda_version_info() -> dict[str, object]: + """Return diagnostic information about CUDA backend availability.""" + return cuda_backend.get_version_info() + + +def find_best_matching_piece( + refs: Tensor, + img: Tensor, + *, + stride: Optional[int] = 4, + mem_save: bool = True, + backend: cuda_backend.Backend = "auto", + cuda_precision: cuda_backend.Precision = "auto", +) -> Tensor: """ Find the best matching piece in refs for each spatial location in img. Args: @@ -16,13 +35,23 @@ def find_best_matching_piece(refs: Tensor, img: Tensor, *, stride: Optional[int] img: Tensor of shape (C, H, W) or (1, C, H, W) representing the input image stride: int, controls how many slices are in one block. If memory is a concern decrease this number. Depending on the hardware and application different values can be optimal. mem_save: bool, should generally be set to True. In rare cases, when the image resolution and the number of reference images is small the naive implementation can be faster. + backend: choose between 'auto', 'torch', and 'cuda'. 'auto' uses the packed CUDA path when possible and falls back to PyTorch otherwise. + cuda_precision: precision for the optional tensor-core CUDA kernel. 'auto' preserves exact FP32 numerics unless PUZZLE_SIM_CUDA_PRECISION is set. Returns: Tensor: the similarity map of the input image to the reference distribution of shape (H, W). """ + cuda_backend.validate_backend(backend) if img.ndim == 3: img = img.unsqueeze(dim=0) + if backend != "torch" and cuda_backend.should_use_packed_cuda(refs, img): + return cuda_backend.find_best_matching_piece(refs, img, precision=cuda_precision) + if backend == "cuda": + raise RuntimeError( + "The CUDA backend requires CUDA float32 tensors and non-gradient reference features." + ) + refs = F.normalize(refs, p=2, dim=1) img = F.normalize(img, p=2, dim=1).squeeze() @@ -72,8 +101,17 @@ def find_best_matching_piece(refs: Tensor, img: Tensor, *, stride: Optional[int] return sim_map + class PuzzleSim(nn.Module): - def __init__(self, reference: Tensor, net_type: NetType = "squeeze", resize: Optional[Tuple[int, int]] = None, verbose: bool = False) -> None: + def __init__( + self, + reference: Tensor, + net_type: NetType = "squeeze", + resize: Optional[Tuple[int, int]] = None, + verbose: bool = False, + backend: cuda_backend.Backend = "auto", + cuda_precision: cuda_backend.Precision = "auto", + ) -> None: """ Instantiates the PuzzleSim metric on a given reference distribution. Find the paper at https://arxiv.org/abs/2411.17489 @@ -81,16 +119,53 @@ def __init__(self, reference: Tensor, net_type: NetType = "squeeze", resize: Opt reference: tensor of shape (N, C, H, W) representing the reference distribution net_type: which base network to use, choose between ['alex','vgg','squeeze']. Defaults to 'squeeze' as detailed in our paper. resize: tuple to resize the references and inputs to. Recommended if the image sizes change or are too large. + backend: 'auto' uses the packed CUDA backend when possible and PyTorch otherwise. Use 'torch' to force the reference implementation. + cuda_precision: precision for the optional tensor-core CUDA backend. 'auto' keeps exact FP32 behavior unless PUZZLE_SIM_CUDA_PRECISION is set. """ super().__init__() + cuda_backend.validate_backend(backend) self.feature_extractor: FeatureExtractor = get_feature_extractor(net_type, verbose=verbose) self.to(reference.device) self.reference = reference - self.reference_feats = None + self.reference_feats: Optional[Dict[int, Tensor]] = None + self._reference_feats_normalize: Optional[bool] = None + self._cuda_refs = cuda_backend.PackedReferenceCache(cuda_precision) self.resize = resize + self.backend = backend if resize is not None: self.reference = resize_tensor(self.reference, resize) + def _ensure_reference_features(self, layers: Sequence[int], normalize: bool) -> None: + if self.reference_feats is None or self._reference_feats_normalize != normalize: + self.reference_feats = {} + self._reference_feats_normalize = normalize + self._cuda_refs.clear() + + missing_layers = [layer for layer in layers if layer not in self.reference_feats] + if missing_layers: + self.reference_feats.update(self.feature_extractor.compute_features(self.reference, missing_layers, normalize)) + + def _find_best_matching_piece( + self, + layer: int, + refs: Tensor, + img: Tensor, + *, + stride: int, + mem_save: bool, + ) -> Tensor: + if self.backend != "torch" and cuda_backend.should_use_packed_cuda(refs, img): + return self._cuda_refs.similarity(layer, refs, img) + if self.backend == "cuda": + raise RuntimeError( + "The CUDA backend requires CUDA float32 tensors and non-gradient reference features." + ) + return find_best_matching_piece(refs, img, stride=stride, mem_save=mem_save, backend="torch") + + def _upsample(self, sim_map: Tensor, out_hw: Tuple[int, int]) -> Tensor: + if self.backend != "torch" and sim_map.is_cuda and sim_map.dim() == 2: + return cuda_backend.bilinear_upsample(sim_map, out_hw, align_corners=True) + return upsample(sim_map, out_hw=out_hw, align_corners=True).squeeze() def forward(self, img: Tensor, *, layers: Sequence[int] = (2, 3, 4), normalize: bool = True, reduction: Literal['mean', 'sum'] = 'sum', weights: Optional[Sequence[float]] = (0.67, 0.2, 0.13), mem_save: bool = True, stride: int = 4) -> Tensor: """ @@ -119,17 +194,17 @@ def forward(self, img: Tensor, *, layers: Sequence[int] = (2, 3, 4), normalize: img = resize_tensor(img, self.resize, align_corners=True) feats = self.feature_extractor.compute_features(img, layers, normalize) - if self.reference_feats is None or any(layer not in self.reference_feats.keys() for layer in layers): - self.reference_feats = self.feature_extractor.compute_features(self.reference, layers, normalize) + self._ensure_reference_features(layers, normalize) + assert self.reference_feats is not None sims: List[Tensor] = [] for i, layer in enumerate(layers): - sim_map = find_best_matching_piece(self.reference_feats[layer], feats[layer], stride=stride, mem_save=mem_save) + sim_map = self._find_best_matching_piece(layer, self.reference_feats[layer], feats[layer], stride=stride, mem_save=mem_save) if weights is not None: sim_map = sim_map * weights[i] - sims.append(upsample(sim_map, out_hw=(H, W), align_corners=True).squeeze()) + sims.append(self._upsample(sim_map, out_hw=(H, W))) sim_summary = sims[0] for sim in sims[1:]: @@ -140,8 +215,3 @@ def forward(self, img: Tensor, *, layers: Sequence[int] = (2, 3, 4), normalize: return sim_summary - - - - - diff --git a/src/puzzle_sim/cuda_backend.py b/src/puzzle_sim/cuda_backend.py new file mode 100644 index 0000000..60949c4 --- /dev/null +++ b/src/puzzle_sim/cuda_backend.py @@ -0,0 +1,294 @@ +from __future__ import annotations + +import os +from typing import Dict, Literal, Optional, Tuple, cast + +import torch +import torch.nn.functional as F +from torch import Tensor + +Precision = Literal["auto", "fp32", "tf32", "fp16"] +ResolvedPrecision = Literal["fp32", "tf32", "fp16"] +Backend = Literal["auto", "torch", "cuda"] + +_VALID_BACKENDS = ("auto", "torch", "cuda") +_VALID_PRECISIONS = ("auto", "fp32", "tf32", "fp16") +_RESOLVED_PRECISIONS = ("fp32", "tf32", "fp16") +_DEFAULT_PRECISION: ResolvedPrecision = "fp32" +_SCORE_CHUNK_BYTES = int(os.environ.get("PUZZLE_SIM_CUDA_SCORE_CHUNK_MB", "256")) * 1024 * 1024 + +try: + from . import _cuda_ext as _ext # type: ignore[attr-defined] + + CUDA_EXT_AVAILABLE = True +except ImportError: # pragma: no cover - depends on optional binary extension + _ext = None + CUDA_EXT_AVAILABLE = False + + +def is_available() -> bool: + """Return True when the optional compiled CUDA extension is importable.""" + return CUDA_EXT_AVAILABLE + + +def validate_backend(backend: Backend) -> None: + """Validate a backend selector.""" + if backend not in _VALID_BACKENDS: + raise ValueError(f"backend must be one of {_VALID_BACKENDS!r}, got {backend!r}.") + + +def should_use_packed_cuda(refs: Tensor, query: Tensor) -> bool: + """True when the packed CUDA/PyTorch matmul backend can safely run.""" + return ( + refs.is_cuda + and query.is_cuda + and refs.dtype == torch.float32 + and query.dtype == torch.float32 + and not refs.requires_grad + ) + + +def grad_active(*tensors: Tensor) -> bool: + """True when autograd should record ops for at least one tensor.""" + return torch.is_grad_enabled() and any(t.requires_grad for t in tensors) + + +def _device_capability_at_least(device: torch.device, major: int, minor: int = 0) -> bool: + if not torch.cuda.is_available(): + return False + device_index = device.index + if device_index is None: + device_index = torch.cuda.current_device() + return torch.cuda.get_device_capability(device_index) >= (major, minor) + + +def resolve_precision(precision: Precision = "auto", device: Optional[torch.device] = None) -> ResolvedPrecision: + """Resolve user/env precision to a supported mode. + + The default is exact FP32 to preserve the public ``puzzle_sim.PuzzleSim`` + numerics. Users who want the inference-only tensor-core kernels can opt in + with ``cuda_precision="tf32"``/``"fp16"`` or ``PUZZLE_SIM_CUDA_PRECISION``. + """ + if precision not in _VALID_PRECISIONS: + raise ValueError(f"cuda_precision must be one of {_VALID_PRECISIONS!r}, got {precision!r}") + + env_precision = os.environ.get("PUZZLE_SIM_CUDA_PRECISION") + if precision == "auto": + precision = cast(Precision, env_precision or _DEFAULT_PRECISION) + if precision not in _RESOLVED_PRECISIONS: + raise ValueError(f"cuda_precision must be one of {_VALID_PRECISIONS!r}, got {precision!r}") + + resolved = cast(ResolvedPrecision, precision) + if resolved != "fp32" and not CUDA_EXT_AVAILABLE: + return "fp32" + if device is None: + device = torch.device("cuda") + if resolved == "tf32" and not _device_capability_at_least(device, 8): + return "fp32" + if resolved == "fp16" and not _device_capability_at_least(device, 7): + return "fp32" + return resolved + + +def normalize_features(features: Tensor, eps: float = 1e-8) -> Tensor: + """Channel-wise L2 normalization with optional CUDA-kernel acceleration.""" + if ( + CUDA_EXT_AVAILABLE + and features.is_cuda + and features.dtype == torch.float32 + and not features.requires_grad + ): + return _ext.normalize_features(features.contiguous(), eps) + norm = torch.sqrt(eps + features.pow(2).sum(dim=1, keepdim=True)) + return features / norm + + +def pack_reference(refs: Tensor) -> Tensor: + """Pack ``(N, C, H, W)`` features as ``(C, N*H*W)`` for the contraction.""" + if CUDA_EXT_AVAILABLE and refs.is_cuda and refs.dtype == torch.float32 and not refs.requires_grad: + return _ext.pack_reference(refs.contiguous()) + n, c, h, w = refs.shape + return refs.transpose(0, 1).contiguous().reshape(c, n * h * w) + + +def refs_for_precision(refs_packed_fp32: Tensor, precision: ResolvedPrecision) -> Tensor: + if precision == "fp16": + return refs_packed_fp32.half().contiguous() + return refs_packed_fp32 + + +class PackedReferenceCache: + """Cache packed reference features for the integrated CUDA backend.""" + + def __init__(self, precision: Precision = "auto") -> None: + self.precision = precision + self._packed_refs: Dict[int, Tensor] = {} + self._packed_refs_fp16: Dict[int, Tensor] = {} + + def clear(self) -> None: + """Clear all cached packed tensors.""" + self._packed_refs.clear() + self._packed_refs_fp16.clear() + + def similarity(self, layer: int, refs: Tensor, query: Tensor) -> Tensor: + """Return the query-vs-reference similarity map for one feature layer.""" + query_requires_grad = grad_active(query) + precision = "fp32" if query_requires_grad else resolve_precision(self.precision, query.device) + refs_packed = self._refs_for_layer(layer, refs, precision) + query_norm = normalize_features(query) + return sim_max(query_norm, refs_packed, precision=precision) + + def _refs_for_layer(self, layer: int, refs: Tensor, precision: ResolvedPrecision) -> Tensor: + refs_packed = self._packed_refs.get(layer) + if refs_packed is None: + refs_norm = normalize_features(refs) + refs_packed = pack_reference(refs_norm) + self._packed_refs[layer] = refs_packed + self._packed_refs_fp16.pop(layer, None) + + if precision != "fp16": + return refs_packed + + refs_packed_fp16 = self._packed_refs_fp16.get(layer) + if refs_packed_fp16 is None: + refs_packed_fp16 = refs_packed.half().contiguous() + self._packed_refs_fp16[layer] = refs_packed_fp16 + return refs_packed_fp16 + + +def sim_max( + query_feats: Tensor, + refs_packed: Tensor, + *, + precision: ResolvedPrecision = "fp32", +) -> Tensor: + """Per-pixel max similarity against packed reference features.""" + if query_feats.dim() == 4: + if query_feats.size(0) != 1: + raise ValueError("The CUDA backend expects a single query image.") + query_feats = query_feats.squeeze(0) + if query_feats.dim() != 3: + raise ValueError(f"query_feats must be 3D or single-image 4D, got shape {tuple(query_feats.shape)}") + + c, qh, qw = query_feats.shape + qhw = qh * qw + query_packed = query_feats.reshape(c, qhw).contiguous() + query_requires_grad = query_packed.requires_grad + + if ( + precision in ("tf32", "fp16") + and CUDA_EXT_AVAILABLE + and query_packed.is_cuda + and not query_requires_grad + ): + if precision == "tf32": + if refs_packed.dtype != torch.float32: + raise TypeError(f"refs_packed must be float32 for tf32, got {refs_packed.dtype}") + return _ext.sim_max_tf32(query_packed, refs_packed, [qh, qw]) + if refs_packed.dtype != torch.float16: + raise TypeError(f"refs_packed must be float16 for fp16, got {refs_packed.dtype}") + return _ext.sim_max_fp16(query_packed.half(), refs_packed, [qh, qw]) + + if refs_packed.dtype != query_packed.dtype: + refs_packed = refs_packed.to(dtype=query_packed.dtype) + + k = refs_packed.size(1) + bytes_per_element = query_packed.element_size() + max_chunk = max(1, _SCORE_CHUNK_BYTES // max(1, qhw * bytes_per_element)) + chunk = min(k, max_chunk) + + query_t = query_packed.transpose(0, 1) + if chunk >= k: + scores = query_t @ refs_packed + return scores.max(dim=1).values.reshape(qh, qw) + + sim_map = torch.full( + (qhw,), + float("-inf"), + device=query_packed.device, + dtype=query_packed.dtype, + ) + for k0 in range(0, k, chunk): + k1 = min(k0 + chunk, k) + partial = query_t @ refs_packed[:, k0:k1] + partial_max = partial.max(dim=1).values + if query_requires_grad: + sim_map = torch.maximum(sim_map, partial_max) + else: + torch.maximum(sim_map, partial_max, out=sim_map) + return sim_map.reshape(qh, qw) + + +def bilinear_upsample(sim_map: Tensor, out_hw: Tuple[int, int], align_corners: bool = True) -> Tensor: + """Upsample a 2D similarity map with optional CUDA-kernel acceleration.""" + if ( + CUDA_EXT_AVAILABLE + and sim_map.is_cuda + and sim_map.dtype == torch.float32 + and sim_map.dim() == 2 + and not sim_map.requires_grad + ): + return _ext.bilinear_upsample(sim_map.contiguous(), list(out_hw), align_corners) + return F.interpolate( + sim_map.unsqueeze(0).unsqueeze(0), + size=out_hw, + mode="bilinear", + align_corners=align_corners, + ).squeeze(0).squeeze(0) + + +def find_best_matching_piece( + refs: Tensor, + img: Tensor, + *, + precision: Precision = "auto", +) -> Tensor: + """CUDA/PyTorch packed implementation of PuzzleSim's spatial max.""" + if img.ndim == 3: + img = img.unsqueeze(0) + if img.ndim != 4 or img.size(0) != 1: + raise ValueError("img must have shape (C, H, W) or (1, C, H, W)") + if refs.ndim != 4: + raise ValueError("refs must have shape (N, C, H, W)") + + query_requires_grad = grad_active(img) + resolved_precision = "fp32" if query_requires_grad else resolve_precision(precision, img.device) + refs_norm = normalize_features(refs) + img_norm = normalize_features(img) + refs_packed = pack_reference(refs_norm) + refs_packed = refs_for_precision(refs_packed, resolved_precision) + return sim_max(img_norm, refs_packed, precision=resolved_precision) + + +def get_version_info() -> dict[str, object]: + """Return runtime information for diagnostics.""" + info: dict[str, object] = { + "cuda_extension_available": CUDA_EXT_AVAILABLE, + "torch_version": torch.__version__, + "cuda_available": torch.cuda.is_available(), + "cuda_device_count": torch.cuda.device_count() if torch.cuda.is_available() else 0, + } + if torch.cuda.is_available(): + info["cuda_device_name"] = torch.cuda.get_device_name(0) + info["cuda_capability"] = torch.cuda.get_device_capability(0) + return info + + +__all__ = [ + "Backend", + "CUDA_EXT_AVAILABLE", + "Precision", + "ResolvedPrecision", + "PackedReferenceCache", + "bilinear_upsample", + "find_best_matching_piece", + "get_version_info", + "is_available", + "normalize_features", + "pack_reference", + "refs_for_precision", + "resolve_precision", + "should_use_packed_cuda", + "sim_max", + "validate_backend", +] diff --git a/puzzle_sim_cuda/src/kernels.cu b/src/puzzle_sim/cuda_ext/kernels.cu similarity index 100% rename from puzzle_sim_cuda/src/kernels.cu rename to src/puzzle_sim/cuda_ext/kernels.cu diff --git a/puzzle_sim_cuda/src/puzzle_sim_cuda.cpp b/src/puzzle_sim/cuda_ext/puzzle_sim_cuda.cpp similarity index 97% rename from puzzle_sim_cuda/src/puzzle_sim_cuda.cpp rename to src/puzzle_sim/cuda_ext/puzzle_sim_cuda.cpp index efda697..f556728 100644 --- a/puzzle_sim_cuda/src/puzzle_sim_cuda.cpp +++ b/src/puzzle_sim/cuda_ext/puzzle_sim_cuda.cpp @@ -281,11 +281,6 @@ torch::Tensor bilinear_upsample( return out; } -// Registers the FusedSqueezeNet class. Implementation lives in -// fused_inference.cpp; forward-declared here so we don't have to drag that -// translation unit's includes into this header-only PYBIND11_MODULE block. -void register_fused_inference(pybind11::module& m); - PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { m.doc() = "CUDA-accelerated kernels for PuzzleSim"; @@ -316,6 +311,4 @@ PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { py::arg("input"), py::arg("output_size"), py::arg("align_corners") = true); - - register_fused_inference(m); } diff --git a/test_cuda_backend.py b/test_cuda_backend.py new file mode 100644 index 0000000..64ae2ce --- /dev/null +++ b/test_cuda_backend.py @@ -0,0 +1,43 @@ +import pytest +import torch + +from puzzle_sim import PuzzleSim, find_best_matching_piece + + +requires_cuda = pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA not available") + + +def test_forced_cuda_backend_requires_cuda_tensors() -> None: + refs = torch.rand(2, 3, 8, 8) + img = refs[0] + + with pytest.raises(RuntimeError, match="CUDA backend requires CUDA float32 tensors"): + find_best_matching_piece(refs, img, backend="cuda") + + +@requires_cuda +def test_find_best_matching_piece_auto_matches_torch_backend() -> None: + refs = torch.rand(3, 5, 8, 7, device="cuda") + img = torch.rand(5, 8, 7, device="cuda") + + expected = find_best_matching_piece(refs, img, backend="torch") + actual = find_best_matching_piece(refs, img, backend="auto") + + assert actual.shape == expected.shape + assert torch.allclose(actual, expected, atol=1e-5, rtol=1e-5) + + +@requires_cuda +def test_puzzlesim_auto_backend_matches_torch_backend() -> None: + refs = torch.rand(2, 3, 64, 64, device="cuda") + img = torch.rand(1, 3, 64, 64, device="cuda") + + torch_model = PuzzleSim(refs, net_type="squeeze", backend="torch") + auto_model = PuzzleSim(refs, net_type="squeeze", backend="auto") + + with torch.no_grad(): + expected = torch_model(img, layers=(1, 2, 3)) + actual = auto_model(img, layers=(1, 2, 3)) + + assert actual.shape == expected.shape + assert torch.allclose(actual, expected, atol=1e-5, rtol=1e-5)