````{grid} 1 1 3 3
:gutter: 3

```{grid-item-card} 🎧 Audio Overview

Listen to an AI-generated overview.

<audio controls style="width: 100%; height: 54px; margin-top: auto;">
  <source src="https://github.com/harvard-edge/cs249r_book/releases/download/tinytorch-audio-v0.1.1/20_capstone.mp3" type="audio/mpeg">
</audio>
```

```{grid-item-card} 🚀 Launch Binder

Run interactively in your browser.

<a href="https://mybinder.org/v2/gh/harvard-edge/cs249r_book/main?labpath=tinytorch%2Fmodules%2F20_capstone%2Fcapstone.ipynb" target="_blank" style="display: flex; align-items: center; justify-content: center; width: 100%; height: 54px; margin-top: auto; background: #f97316; color: white; text-align: center; text-decoration: none; border-radius: 27px; font-size: 14px; box-sizing: border-box;">Open in Binder →</a>
```

```{grid-item-card} 📄 View Source

Browse the source code on GitHub.

<a href="https://github.com/harvard-edge/cs249r_book/blob/main/tinytorch/src/20_capstone/20_capstone.py" target="_blank" style="display: flex; align-items: center; justify-content: center; width: 100%; height: 54px; margin-top: auto; background: #14b8a6; color: white; text-align: center; text-decoration: none; border-radius: 27px; font-size: 14px; box-sizing: border-box;">View on GitHub →</a>
```

````

```{raw} html
<style>
.slide-viewer-container {
  margin: 0.5rem 0 1.5rem 0;
  background: #0f172a;
  border-radius: 1rem;
  overflow: hidden;
  box-shadow: 0 4px 20px rgba(0,0,0,0.15);
}
.slide-header {
  display: flex;
  align-items: center;
  justify-content: space-between;
  padding: 0.6rem 1rem;
  background: rgba(255,255,255,0.03);
}
.slide-title {
  display: flex;
  align-items: center;
  gap: 0.5rem;
  color: #94a3b8;
  font-weight: 500;
  font-size: 0.85rem;
}
.slide-subtitle {
  color: #64748b;
  font-weight: 400;
  font-size: 0.75rem;
}
.slide-toolbar {
  display: flex;
  align-items: center;
  gap: 0.375rem;
}
.slide-toolbar button {
  background: transparent;
  border: none;
  color: #64748b;
  width: 32px;
  height: 32px;
  border-radius: 0.375rem;
  cursor: pointer;
  font-size: 1.1rem;
  transition: all 0.15s;
  display: flex;
  align-items: center;
  justify-content: center;
}
.slide-toolbar button:hover {
  background: rgba(249, 115, 22, 0.15);
  color: #f97316;
}
.slide-nav-group {
  display: flex;
  align-items: center;
}
.slide-page-info {
  color: #64748b;
  font-size: 0.75rem;
  padding: 0 0.5rem;
  font-weight: 500;
}
.slide-zoom-group {
  display: flex;
  align-items: center;
  margin-left: 0.25rem;
  padding-left: 0.5rem;
  border-left: 1px solid rgba(255,255,255,0.1);
}
.slide-canvas-wrapper {
  display: flex;
  justify-content: center;
  align-items: center;
  padding: 0.5rem 1rem 1rem 1rem;
  min-height: 380px;
  background: #0f172a;
}
.slide-canvas {
  max-width: 100%;
  max-height: 350px;
  height: auto;
  border-radius: 0.5rem;
  box-shadow: 0 4px 24px rgba(0,0,0,0.4);
}
.slide-progress-wrapper {
  padding: 0 1rem 0.5rem 1rem;
}
.slide-progress-bar {
  height: 3px;
  background: rgba(255,255,255,0.08);
  border-radius: 1.5px;
  overflow: hidden;
  cursor: pointer;
}
.slide-progress-fill {
  height: 100%;
  background: #f97316;
  border-radius: 1.5px;
  transition: width 0.2s ease;
}
.slide-loading {
  color: #f97316;
  font-size: 0.9rem;
  display: flex;
  align-items: center;
  gap: 0.5rem;
}
.slide-loading::before {
  content: '';
  width: 18px;
  height: 18px;
  border: 2px solid rgba(249, 115, 22, 0.2);
  border-top-color: #f97316;
  border-radius: 50%;
  animation: slide-spin 0.8s linear infinite;
}
@keyframes slide-spin {
  to { transform: rotate(360deg); }
}
.slide-footer {
  display: flex;
  justify-content: center;
  gap: 0.5rem;
  padding: 0.6rem 1rem;
  background: rgba(255,255,255,0.02);
  border-top: 1px solid rgba(255,255,255,0.05);
}
.slide-footer a {
  display: inline-flex;
  align-items: center;
  gap: 0.375rem;
  background: #f97316;
  color: white;
  padding: 0.4rem 0.9rem;
  border-radius: 2rem;
  text-decoration: none;
  font-weight: 500;
  font-size: 0.75rem;
  transition: all 0.15s;
}
.slide-footer a:hover {
  background: #ea580c;
  color: white;
}
.slide-footer a.secondary {
  background: transparent;
  color: #94a3b8;
  border: 1px solid rgba(255,255,255,0.15);
}
.slide-footer a.secondary:hover {
  background: rgba(255,255,255,0.05);
  color: #f8fafc;
}
@media (max-width: 600px) {
  .slide-header { flex-direction: column; gap: 0.5rem; padding: 0.5rem 0.75rem; }
  .slide-toolbar button { width: 28px; height: 28px; }
  .slide-canvas-wrapper { min-height: 260px; padding: 0.5rem; }
  .slide-canvas { max-height: 220px; }
}
</style>

<div class="slide-viewer-container" id="slide-viewer-20_capstone">
  <div class="slide-header">
    <div class="slide-title">
      <span>🔥</span>
      <span>Slide Deck</span>
      <span class="slide-subtitle">· AI-generated</span>
    </div>
    <div class="slide-toolbar">
      <div class="slide-nav-group">
        <button onclick="slideNav('20_capstone', -1)" title="Previous">‹</button>
        <span class="slide-page-info"><span id="slide-num-20_capstone">1</span> / <span id="slide-count-20_capstone">-</span></span>
        <button onclick="slideNav('20_capstone', 1)" title="Next">›</button>
      </div>
      <div class="slide-zoom-group">
        <button onclick="slideZoom('20_capstone', -0.25)" title="Zoom out">−</button>
        <button onclick="slideZoom('20_capstone', 0.25)" title="Zoom in">+</button>
      </div>
    </div>
  </div>
  <div class="slide-canvas-wrapper">
    <div id="slide-loading-20_capstone" class="slide-loading">Loading slides...</div>
    <canvas id="slide-canvas-20_capstone" class="slide-canvas" style="display:none;"></canvas>
  </div>
  <div class="slide-progress-wrapper">
    <div class="slide-progress-bar" onclick="slideProgress('20_capstone', event)">
      <div class="slide-progress-fill" id="slide-progress-20_capstone" style="width: 0%;"></div>
    </div>
  </div>
  <div class="slide-footer">
    <a href="../_static/slides/20_capstone.pdf" download>⬇ Download</a>
    <a href="#" onclick="slideFullscreen('20_capstone'); return false;" class="secondary">⛶ Fullscreen</a>
  </div>
</div>

<script src="https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.11.174/pdf.min.js"></script>
<script>
(function() {
  if (window.slideViewersInitialized) return;
  window.slideViewersInitialized = true;

  pdfjsLib.GlobalWorkerOptions.workerSrc = 'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.11.174/pdf.worker.min.js';

  window.slideViewers = {};

  window.initSlideViewer = function(id, pdfUrl) {
    const viewer = { pdf: null, page: 1, scale: 1.3, rendering: false, pending: null };
    window.slideViewers[id] = viewer;

    const canvas = document.getElementById('slide-canvas-' + id);
    const ctx = canvas.getContext('2d');

    function render(num) {
      viewer.rendering = true;
      viewer.pdf.getPage(num).then(function(page) {
        const viewport = page.getViewport({scale: viewer.scale});
        canvas.height = viewport.height;
        canvas.width = viewport.width;
        page.render({canvasContext: ctx, viewport: viewport}).promise.then(function() {
          viewer.rendering = false;
          if (viewer.pending !== null) { render(viewer.pending); viewer.pending = null; }
        });
      });
      document.getElementById('slide-num-' + id).textContent = num;
      document.getElementById('slide-progress-' + id).style.width = (num / viewer.pdf.numPages * 100) + '%';
    }

    function queue(num) { if (viewer.rendering) viewer.pending = num; else render(num); }

    pdfjsLib.getDocument(pdfUrl).promise.then(function(pdf) {
      viewer.pdf = pdf;
      document.getElementById('slide-count-' + id).textContent = pdf.numPages;
      document.getElementById('slide-loading-' + id).style.display = 'none';
      canvas.style.display = 'block';
      render(1);
    }).catch(function() {
      document.getElementById('slide-loading-' + id).innerHTML = 'Unable to load. <a href="' + pdfUrl + '" style="color:#f97316;">Download PDF</a>';
    });

    viewer.queue = queue;
  };

  window.slideNav = function(id, dir) {
    const v = window.slideViewers[id];
    if (!v || !v.pdf) return;
    const newPage = v.page + dir;
    if (newPage >= 1 && newPage <= v.pdf.numPages) { v.page = newPage; v.queue(newPage); }
  };

  window.slideZoom = function(id, delta) {
    const v = window.slideViewers[id];
    if (!v) return;
    v.scale = Math.max(0.5, Math.min(3, v.scale + delta));
    v.queue(v.page);
  };

  window.slideProgress = function(id, event) {
    const v = window.slideViewers[id];
    if (!v || !v.pdf) return;
    const bar = event.currentTarget;
    const pct = (event.clientX - bar.getBoundingClientRect().left) / bar.offsetWidth;
    const newPage = Math.max(1, Math.min(v.pdf.numPages, Math.ceil(pct * v.pdf.numPages)));
    if (newPage !== v.page) { v.page = newPage; v.queue(newPage); }
  };

  window.slideFullscreen = function(id) {
    const el = document.getElementById('slide-viewer-' + id);
    if (el.requestFullscreen) el.requestFullscreen();
    else if (el.webkitRequestFullscreen) el.webkitRequestFullscreen();
  };
})();

initSlideViewer('20_capstone', '../_static/slides/20_capstone.pdf');
</script>
```

- **Implement** comprehensive benchmarking infrastructure measuring accuracy, latency, throughput, and memory
- **Master** the three pillars of reliable benchmarking: repeatability, comparability, and completeness
- **Understand** performance measurement traps (variance, cold starts, batch effects) and how to avoid them
- **Connect** your TinyTorch implementation to production ML workflows (experiment tracking, A/B testing, regression detection)
- **Generate** schema-validated JSON submissions that enable reproducible comparisons and community sharing

:align: center
:caption: Benchmarking System
flowchart LR
    subgraph "Benchmarking System"
        A["BenchmarkReport
measure performance"]
        B["Submission
standardized format"]
        C["Validation
schema compliance"]
    end

    subgraph "Workflow"
        D["Baseline Model"]
        E["Optimization"]
        F["Comparison"]
    end

    D --> A
    E --> A
    A --> B
    B --> C
    A --> F

    style A fill:#e1f5ff
    style B fill:#fff3cd
    style C fill:#f8d7da
    style D fill:#d4edda
    style E fill:#e2d5f1
    style F fill:#ffe4e1

# Professional ML workflow
report = BenchmarkReport(model_name="my_model")
report.benchmark_model(model, X_test, y_test, num_runs=100)

submission = generate_submission(
    baseline_report=baseline_report,
    optimized_report=optimized_report,
    techniques_applied=["quantization", "pruning"]
)
save_submission(submission, "results.json")

BenchmarkReport(model_name: str = "model") -> BenchmarkReport

from tinytorch.core.tensor import Tensor
from tinytorch.core.layers import Linear
from tinytorch.core.activations import ReLU
from tinytorch.core.losses import CrossEntropyLoss

# These imports use try/except blocks for graceful degradation
try:
    from tinytorch.perf.profiling import Profiler, quick_profile
    from tinytorch.perf.compression import magnitude_prune, structured_prune
    from tinytorch.perf.benchmarking import Benchmark, BenchmarkResult
except ImportError:
    # Core benchmarking still works without optimization modules
    pass

# Measure latency with statistical rigor
latencies = []
for _ in range(num_runs):
    start = time.time()
    _ = model.forward(X_test[:1])  # Single sample inference
    latencies.append((time.time() - start) * 1000)  # Convert to ms

avg_latency = np.mean(latencies)
std_latency = np.std(latencies)

def _get_system_info(self):
    """Collect system information for reproducibility."""
    return {
        'platform': platform.platform(),
        'python_version': sys.version.split()[0],
        'numpy_version': np.__version__
    }

self.metrics = {
    'parameter_count': int(param_count),
    'model_size_mb': float(model_size_mb),
    'accuracy': float(accuracy),
    'latency_ms_mean': float(avg_latency),
    'latency_ms_std': float(std_latency),
    'throughput_samples_per_sec': float(1000 / avg_latency)
}

# Latency: time for ONE sample
start = time.time()
_ = model.forward(X_test[:1])  # Shape: (1, features)
latency_ms = (time.time() - start) * 1000

:tags: [remove-input, remove-output]
from myst_nb import glue

# Latency vs Throughput: derived metrics
lt_latency_ms = 10
lt_throughput = 1000 / lt_latency_ms
glue("lt_throughput", f"{lt_throughput:.0f}")

lt_batch_size = 32
lt_batch_time_ms = 50
lt_batch_throughput = lt_batch_size * 1000 / lt_batch_time_ms
glue("lt_batch_throughput", f"{lt_batch_throughput:.0f}")

throughput_samples_per_sec = 1000 / avg_latency

latencies = []
for _ in range(num_runs):
    start = time.time()
    _ = model.forward(X_test[:1])
    latencies.append((time.time() - start) * 1000)

avg_latency = np.mean(latencies)
std_latency = np.std(latencies)  # Captures variance

submission['improvements'] = {
    'speedup': float(baseline_latency / optimized_latency),
    'compression_ratio': float(baseline_size / optimized_size),
    'accuracy_delta': float(
        optimized_report.metrics['accuracy'] - baseline_report.metrics['accuracy']
    )
}

# Schema-enforced format
'accuracy': float(accuracy)  # Always 0.0-1.0 float

# Validation catches errors
assert 0 <= metrics['accuracy'] <= 1, "Accuracy must be in [0, 1]"

# Aggregate community results automatically
all_submissions = [load_json(f) for f in submission_files]
avg_accuracy = np.mean([s['baseline']['metrics']['accuracy']
                        for s in all_submissions])

# Build leaderboards
sorted_by_speedup = sorted(all_submissions,
                           key=lambda s: s['improvements']['speedup'],
                           reverse=True)

# Detect regressions in CI/CD
if new_latency > baseline_latency * 1.1:
    raise Exception("Performance regression: 10% slower!")

# Prepare data BEFORE timing
X = create_test_input()

# Time ONLY the operation you care about
start = time.time()
output = model.forward(X)  # Only this is timed
latency = time.time() - start

# Process output AFTER timing
predictions = postprocess(output)

````{tab-item} Your TinyTorch
```python
from tinytorch.olympics import BenchmarkReport, generate_submission

# Benchmark baseline
baseline_report = BenchmarkReport(model_name="my_model")
baseline_report.benchmark_model(model, X_test, y_test, num_runs=100)

# Benchmark optimized
optimized_report = BenchmarkReport(model_name="optimized_model")
optimized_report.benchmark_model(opt_model, X_test, y_test, num_runs=100)

# Generate submission
submission = generate_submission(
    baseline_report=baseline_report,
    optimized_report=optimized_report,
    techniques_applied=["quantization", "pruning"]
)

save_submission(submission, "results.json")
```
````

````{tab-item} Production MLflow
```python
import mlflow

# Track baseline experiment
with mlflow.start_run(run_name="baseline"):
    mlflow.log_params({"model": "my_model"})
    metrics = benchmark_model(model, X_test, y_test)
    mlflow.log_metrics(metrics)
    mlflow.log_artifact("model.pkl")

# Track optimized experiment
with mlflow.start_run(run_name="optimized"):
    mlflow.log_params({"model": "optimized_model",
                       "techniques": ["quantization", "pruning"]})
    metrics = benchmark_model(opt_model, X_test, y_test)
    mlflow.log_metrics(metrics)
    mlflow.log_artifact("optimized_model.pkl")

# Compare experiments in MLflow UI
```
````

The workflow pattern: baseline → optimize → benchmark → compare → decide. Whether you use TinyTorch or MLflow, this cycle is fundamental to production ML. The tools scale, but the methodology remains the same.

:tags: [remove-input, remove-output]
from myst_nb import glue

# Model serving cost calculation
scale_requests_per_day = 10_000_000
scale_latency_before_ms = 20
scale_latency_after_ms = 10
scale_saved_ms = scale_latency_before_ms - scale_latency_after_ms
scale_seconds_saved = scale_requests_per_day * scale_saved_ms / 1000
scale_days_saved = scale_seconds_saved / 86400
scale_cost_reduction_pct = (scale_saved_ms / scale_latency_before_ms) * 100

glue("scale_seconds_saved", f"{scale_seconds_saved:,.0f}")
glue("scale_days_saved", f"{scale_days_saved:.2f}")
glue("scale_cost_reduction", f"{scale_cost_reduction_pct:.0f}%")

# Training pipeline savings
scale_training_cost = 1_000_000
scale_data_loading_pct = 60
scale_pipeline_savings = scale_training_cost * scale_data_loading_pct / 100

glue("scale_pipeline_savings", f"${scale_pipeline_savings:,.0f}")

:tags: [remove-input, remove-output]
from myst_nb import glue

# Q1: Memory calculation (FP32 vs INT8 quantization)
# Using binary units: 1 MB = 1024^2 = 1,048,576 bytes
q1_params = 5_000_000
q1_fp32_bytes_per_param = 4
q1_int8_bytes_per_param = 1
q1_bytes_per_mb = 1024 ** 2

q1_fp32_bytes = q1_params * q1_fp32_bytes_per_param
q1_int8_bytes = q1_params * q1_int8_bytes_per_param
q1_fp32_mb = q1_fp32_bytes / q1_bytes_per_mb
q1_int8_mb = q1_int8_bytes / q1_bytes_per_mb
q1_savings_mb = q1_fp32_mb - q1_int8_mb
q1_reduction_pct = q1_savings_mb / q1_fp32_mb * 100
q1_compression = q1_fp32_mb / q1_int8_mb

glue("q1_fp32_bytes", f"{q1_fp32_bytes:,}")
glue("q1_fp32_mb", f"{q1_fp32_mb:.2f}")
glue("q1_int8_bytes", f"{q1_int8_bytes:,}")
glue("q1_int8_mb", f"{q1_int8_mb:.2f}")
glue("q1_savings_mb", f"{q1_savings_mb:.2f}")
glue("q1_reduction_pct", f"{q1_reduction_pct:.0f}%")
glue("q1_compression", f"{q1_compression:.1f}x")

:class: dropdown

FP32: 5,000,000 parameters x 4 bytes = {glue:text}`q1_fp32_bytes` bytes = **{glue:text}`q1_fp32_mb` MB**

INT8: 5,000,000 parameters x 1 byte = {glue:text}`q1_int8_bytes` bytes = **{glue:text}`q1_int8_mb` MB**

Savings: {glue:text}`q1_fp32_mb` MB - {glue:text}`q1_int8_mb` MB = **{glue:text}`q1_savings_mb` MB** ({glue:text}`q1_reduction_pct` reduction)

Compression ratio: {glue:text}`q1_fp32_mb` MB / {glue:text}`q1_int8_mb` MB = **{glue:text}`q1_compression`**

This is why quantization is standard in mobile deployment—models must fit in tight memory budgets.

:tags: [remove-input, remove-output]
from myst_nb import glue

# Q2: Latency variance analysis (95% confidence = +/- 2 std)
q2_mean = 10.0
q2_std_a = 0.3
q2_std_b = 3.0
q2_variance_ratio = q2_std_b / q2_std_a
q2_a_lo = q2_mean - 2 * q2_std_a
q2_a_hi = q2_mean + 2 * q2_std_a
q2_b_lo = q2_mean - 2 * q2_std_b
q2_b_hi = q2_mean + 2 * q2_std_b

glue("q2_variance_ratio", f"{q2_variance_ratio:.0f}x")
glue("q2_a_lo", f"{q2_a_lo:.1f}")
glue("q2_a_hi", f"{q2_a_hi:.1f}")
glue("q2_b_lo", f"{q2_b_lo:.1f}")
glue("q2_b_hi", f"{q2_b_hi:.1f}")

:class: dropdown

**Deploy Model A.**

Same mean latency (10.0ms) but Model A has {glue:text}`q2_variance_ratio` lower variance (0.3ms vs 3.0ms std).

Model A's latency range: ~{glue:text}`q2_a_lo`-{glue:text}`q2_a_hi`ms (95% confidence: +/- 2 std)
Model B's latency range: ~{glue:text}`q2_b_lo`-{glue:text}`q2_b_hi`ms (95% confidence: +/- 2 std)

**Why consistency matters:**
- Users prefer predictable performance over erratic speed
- High variance suggests GC pauses, cache misses, or resource contention
- Production SLAs commit to p99 latency—Model B's p99 could be 16ms vs Model A's 11ms

In production, **reliability > mean performance**. A consistently decent experience beats an unreliable fast one.

:tags: [remove-input, remove-output]
from myst_nb import glue

# Q3: Batch size trade-off — why amortized != actual per-sample latency
# Given: batch=32 takes 100ms total, batch=1 takes 8ms actual
# Solve system of equations:
#   batch_total = fixed + batch_size * variable_per_sample
#   batch1_total = fixed + 1 * variable_per_sample
# => fixed = (batch_total - batch_size * batch1) / (1 - batch_size)
q3_batch_size = 32
q3_batch_total_ms = 100
q3_batch1_actual_ms = 8.0

q3_amortized = q3_batch_total_ms / q3_batch_size
q3_fixed = (q3_batch_total_ms - q3_batch_size * q3_batch1_actual_ms) / (1 - q3_batch_size)
q3_var_total = q3_batch_total_ms - q3_fixed
q3_var_per_sample = q3_var_total / q3_batch_size
q3_batch1_check = q3_fixed + q3_var_per_sample

glue("q3_amortized", f"{q3_amortized:.1f}")
glue("q3_fixed", f"{q3_fixed:.1f}")
glue("q3_var_total", f"{q3_var_total:.1f}")
glue("q3_var_per_sample", f"{q3_var_per_sample:.1f}")
glue("q3_batch1_check", f"{q3_batch1_check:.1f}")

:class: dropdown

**No.** This underestimates per-sample latency.

Batching amortizes fixed overhead (data transfer, kernel launch). Per-sample latency at batch=1 is higher than batch=32 divided by 32.

Example reality:
- Batch=32: 100ms total → {glue:text}`q3_amortized`ms per sample (amortized)
- Batch=1: 8ms total → 8ms per sample (actual)

**Why the discrepancy?**
- Fixed overhead: {glue:text}`q3_fixed`ms (data transfer, setup)
- Variable cost: {glue:text}`q3_var_total`ms / 32 = {glue:text}`q3_var_per_sample`ms per sample
- At batch=1: {glue:text}`q3_fixed`ms fixed + {glue:text}`q3_var_per_sample`ms variable = {glue:text}`q3_batch1_check`ms

**Always benchmark at deployment batch size.** If production serves single requests, measure with batch=1.

:tags: [remove-input, remove-output]
from myst_nb import glue

# Q4: Speedup and real-world impact
q4_baseline_ms = 20
q4_optimized_ms = 5
q4_speedup = q4_baseline_ms / q4_optimized_ms

q4_baseline_rps = 100  # requests/sec (given scenario)
q4_optimized_rps = q4_baseline_rps * q4_speedup
q4_baseline_cost = 1000  # $/month (given scenario)
q4_optimized_cost = q4_baseline_cost / q4_speedup

q4_baseline_util = 60  # % utilization (given scenario)
q4_optimized_util = q4_baseline_util / q4_speedup
q4_headroom = 100 - q4_optimized_util

glue("q4_speedup", f"{q4_speedup:.1f}x")
glue("q4_times_faster", f"{q4_speedup:.0f}")
glue("q4_optimized_rps", f"{q4_optimized_rps:.0f}")
glue("q4_optimized_cost", f"${q4_optimized_cost:.0f}")
glue("q4_headroom", f"{q4_headroom:.0f}%")

:class: dropdown

Speedup = baseline_latency / optimized_latency = 20ms / 5ms = **{glue:text}`q4_speedup`**

**What it means:**
- Optimized model is **{glue:text}`q4_times_faster` times faster**
- Processes same input in 1/{glue:text}`q4_times_faster` the time
- Can handle {glue:text}`q4_times_faster`x more traffic with same hardware

**Real-world impact:**
- If baseline served 100 requests/sec, optimized serves {glue:text}`q4_optimized_rps` requests/sec
- If baseline cost $1000/month in compute, optimized costs {glue:text}`q4_optimized_cost`/month
- If baseline met latency SLA at 60% utilization, optimized has {glue:text}`q4_headroom` headroom

**Note:** Speedup alone doesn't tell the full story. Check accuracy_delta and compression_ratio to understand trade-offs.

:class: dropdown

**Type safety enables automation.**

Without schema:
```python
# Different submissions, different formats (breaks aggregation)
{"accuracy": "92%"}      # String
{"accuracy": 92}         # Integer (out of 100)
{"accuracy": 0.92}       # Float
{"accuracy": "good"}     # Non-numeric
```

Aggregating these requires manual parsing and error handling.

With schema:
```python
# All submissions use same format (aggregation works)
{"accuracy": 0.92}  # Always float in [0.0, 1.0]
```

**Benefits:**
1. **Automated validation** - Reject invalid submissions immediately
2. **Aggregation** - `np.mean([s['accuracy'] for s in submissions])` just works
3. **Comparison** - Sort by accuracy without parsing different formats
4. **APIs** - Other tools can consume submissions without custom parsers

**Real example:** Papers with Code leaderboards require strict schemas. Thousands of submissions from different teams aggregate automatically because everyone follows the same format.

You've built a complete ML framework from scratch—from basic tensors to production-ready benchmarking. You understand how PyTorch works under the hood, how optimizations affect performance, and how to measure and document results professionally. These skills transfer directly to production ML engineering.

- **[Launch Binder](https://mybinder.org/v2/gh/harvard-edge/cs249r_book/main?urlpath=lab/tree/tinytorch/modules/20_capstone/capstone.ipynb)** - Run interactively in browser, no setup required
- **[View Source](https://github.com/harvard-edge/cs249r_book/blob/main/tinytorch/src/20_capstone/20_capstone.py)** - Browse the implementation code

Binder sessions are temporary. Download your completed notebook when done, or clone the repository for persistent local work.