From 27fb0e98b3f918524b04fe9d32711d791e799e10 Mon Sep 17 00:00:00 2001 From: Zini Chakraborty Date: Wed, 8 Jul 2026 01:49:32 -0700 Subject: [PATCH 1/4] docs: add sustainability benchmarking tutorial --- .../evaluation_agent_sustainability.ipynb | 430 ++++++++++++++++++ 1 file changed, 430 insertions(+) create mode 100644 docs/tutorials/evaluation_agent_sustainability.ipynb diff --git a/docs/tutorials/evaluation_agent_sustainability.ipynb b/docs/tutorials/evaluation_agent_sustainability.ipynb new file mode 100644 index 00000000..57c25134 --- /dev/null +++ b/docs/tutorials/evaluation_agent_sustainability.ipynb @@ -0,0 +1,430 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "zYI71djJxM63" + }, + "source": [ + "# Evaluating Sustainability using EvaluationAgent" + ] + }, + { + "cell_type": "raw", + "metadata": { + "vscode": { + "languageId": "raw" + }, + "id": "FZ-4_M4fxM64" + }, + "source": [ + "\n", + " \"Open\n", + "" + ] + }, + { + "cell_type": "markdown", + "source": [ + "This tutorial demonstrates how to use the `pruna` package to evaluate the sustainability of a model. Image generation is among the most energy-intensive inference workloads. Compression methods promise to reduce this, but their savings vary with hardware and workload, so the only way to know what a method actually saves *for you* is to measure it. Sustainability benchmarks make those savings visible and comparable.\n", + "\n", + "We will use the `stable-diffusion-v1-5` model and a subset of the `LAION256` dataset, comparing a baseline against two optimization methods (`deepcache` and `torch_compile`). Any execution times given below are measured on a T4 GPU." + ], + "metadata": { + "id": "1odA2-O0aztf" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "HfEXSjYWxM64" + }, + "outputs": [], + "source": [ + "# if you are not running the latest version of this tutorial, make sure to install the matching version of pruna\n", + "# the following command will install the latest version of pruna\n", + "%pip install pruna" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OCoHdvckxM64" + }, + "source": [ + "### 1. Loading the model\n", + "\n", + "First, load your model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4PMNwfOOxM64" + }, + "outputs": [], + "source": [ + "import torch\n", + "from diffusers import AutoPipelineForText2Image\n", + "\n", + "from pruna.engine.pruna_model import PrunaModel\n", + "\n", + "pipe = AutoPipelineForText2Image.from_pretrained(\n", + " \"stable-diffusion-v1-5/stable-diffusion-v1-5\",\n", + " torch_dtype=torch.float16,\n", + " use_safetensors=True,\n", + ")\n", + "pipe = pipe.to(\"cuda\")\n", + "model = PrunaModel(pipe)\n", + "pipe.set_progress_bar_config(disable=True)\n", + "\n", + "# Shared generation parameters, applied to every configuration so results are comparable\n", + "GEN_ARGS = {\"num_inference_steps\": 25, \"guidance_scale\": 7.5}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Zgvuf3dZxM64" + }, + "source": [ + "### 2. Benchmark metrics\n", + "\n", + "`pruna` tracks three sustainability metrics:\n", + "\n", + "- **`total_time`**: wall-clock time to run the benchmark iterations (ms)\n", + "- **`energy_consumed`**: total energy drawn during inference (kWh)\n", + "- **`co2_emissions`**: estimated CO2-equivalent emissions based on energy consumed and hardware location (kg)\n", + "\n", + "We also include **`clip_score`**, a quality metric measuring how well generated images match their prompts, so we can check whether efficiency gains come at a quality cost.\n", + "\n", + "We will pass these metrics to the evaluation `Task` as a list of metric instances. For other ways to specify metrics, see the [evaluation documentation](https://docs.pruna.ai/en/stable/docs_pruna/user_manual/evaluate.html)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "yTBJuCTNxM65" + }, + "outputs": [], + "source": [ + "from pruna.evaluation.metrics import (\n", + " TotalTimeMetric, EnergyConsumedMetric, CO2EmissionsMetric, TorchMetricWrapper,\n", + ")\n", + "\n", + "request = [\n", + " TotalTimeMetric(n_iterations=10, n_warmup_iterations=3),\n", + " EnergyConsumedMetric(n_iterations=10, n_warmup_iterations=3),\n", + " CO2EmissionsMetric(n_iterations=10, n_warmup_iterations=3),\n", + " TorchMetricWrapper(\"clip_score\"),\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vFhRH1YCxM65" + }, + "source": [ + "### 3. Create an EvaluationAgent and a Task\n", + "\n", + "Pruna's evaluation process uses a Task to define which metrics to calculate and provide the evaluation data. The EvaluationAgent then takes this Task and handles running the model inference, passing the inputs, ground truth, and predictions to each metric, and collecting the results.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wSIDHfEoxM65" + }, + "outputs": [], + "source": [ + "from pruna.data.pruna_datamodule import PrunaDataModule\n", + "from pruna.evaluation.evaluation_agent import EvaluationAgent\n", + "from pruna.evaluation.task import Task\n", + "\n", + "datamodule = PrunaDataModule.from_string(\"LAION256\")\n", + "datamodule.limit_datasets(10) # Quality metrics run over these 10 samples. Timing metrics benchmark a single batch\n", + "task = Task(request, datamodule)\n", + "eval_agent = EvaluationAgent(task)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7tKFVEQPxM65" + }, + "source": [ + "### 4. Evaluate the baseline model\n", + "\n", + "We can evaluate a model by calling the `evaluate` method of the EvaluationAgent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wWvxYQvMxM65" + }, + "outputs": [], + "source": [ + "model.inference_handler.model_args.update(GEN_ARGS)\n", + "\n", + "base_results = eval_agent.evaluate(model)\n", + "for r in base_results:\n", + " print(f\"{r.name}: {r.result:.4g}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KT_eDmagxM65" + }, + "source": [ + "### 5. Smash the model with DeepCache" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "XGcu7t-8xM65" + }, + "outputs": [], + "source": [ + "import copy\n", + "\n", + "from pruna import smash\n", + "from pruna.config.smash_config import SmashConfig\n", + "from pruna.engine.utils import safe_memory_cleanup\n", + "\n", + "smash_config = SmashConfig()\n", + "smash_config.add(dict(deepcache=True))\n", + "\n", + "pipe = pipe.to(\"cpu\")\n", + "safe_memory_cleanup()\n", + "\n", + "copy_pipe = copy.deepcopy(pipe).to(\"cuda\")\n", + "smashed_pipe = smash(copy_pipe, smash_config)\n", + "smashed_pipe.set_progress_bar_config(disable=True)\n", + "smashed_pipe.inference_handler.model_args.update(GEN_ARGS)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_g5UNUW2xM65" + }, + "source": [ + "### 6. Evaluate the first smashed model (DeepCache)\n", + "\n", + "We now evaluate the smashed model by calling evaluate again." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "DBPyC0O4xM65" + }, + "outputs": [], + "source": [ + "smashed_results = eval_agent.evaluate(smashed_pipe)\n", + "for r in smashed_results:\n", + " print(f\"{r.name}: {r.result:.4g}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fbtvUWW9xM65" + }, + "source": [ + "### 7. Analyze baseline vs DeepCache\n", + "\n", + "With both configurations evaluated on the same task, we can now compare them side by side. For time, energy, and CO2 a negative change is an improvement. For CLIP score, higher is better." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "M8baXC6axM65" + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "base = {r.name: r.result for r in base_results}\n", + "smashed = {r.name: r.result for r in smashed_results}\n", + "\n", + "metrics = {\n", + " \"Inference time (s)\": (\"total_time\", 1e-3), # ms -> s\n", + " \"Energy (Wh)\": (\"energy_consumed\", 1e3), # kWh -> Wh\n", + " \"CO2 emissions (g)\": (\"co2_emissions\", 1e3), # kg -> g\n", + " \"CLIP score\": (\"clip_score\", 1),\n", + "}\n", + "\n", + "fig, axes = plt.subplots(1, 4, figsize=(15, 4), layout=\"constrained\")\n", + "\n", + "for ax, (label, (key, scale)) in zip(axes, metrics.items()):\n", + " values = [base[key] * scale, smashed[key] * scale]\n", + " bars = ax.bar([\"Baseline\", \"DeepCache\"], values, color=[\"#8a8a8a\", \"#7c3aed\"])\n", + " change = (values[1] / values[0] - 1) * 100\n", + " ax.bar_label(bars, labels=[f\"{values[0]:.3f}\", f\"{values[1]:.3f}\\n({change:+.1f}%)\"], fontsize=9)\n", + " ax.set_ylim(0, max(values) * 1.3)\n", + " ax.set_title(label)\n", + "\n", + "fig.suptitle(\"Benchmark metrics: baseline vs. DeepCache\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "source": [ + "### 8. Smash the model with torch_compile" + ], + "metadata": { + "id": "lf5yG4hBsGr1" + } + }, + { + "cell_type": "code", + "source": [ + "# Free the DeepCache pipeline before building the next configuration\n", + "del smashed_pipe\n", + "safe_memory_cleanup()\n", + "\n", + "# Smash with torch.compile (start from a fresh copy of the original pipe)\n", + "compile_config = SmashConfig()\n", + "compile_config.add(dict(torch_compile=True))\n", + "\n", + "compile_pipe = smash(copy.deepcopy(pipe).to(\"cuda\"), compile_config)\n", + "compile_pipe.set_progress_bar_config(disable=True)\n", + "compile_pipe.inference_handler.model_args.update(GEN_ARGS)" + ], + "metadata": { + "id": "5KpMar6gsdH3" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### 9. Evaluate the second smashed model (torch_compile)" + ], + "metadata": { + "id": "T6Igrkx1tR2Y" + } + }, + { + "cell_type": "code", + "source": [ + "compiled_results = eval_agent.evaluate(compile_pipe)\n", + "for r in compiled_results:\n", + " print(f\"{r.name}: {r.result:.4g}\")" + ], + "metadata": { + "id": "8v_mndBYtJPf" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### 10. Analyze baseline vs DeepCache vs torch_compile\n", + "\n", + "With all three configurations evaluated on the same task, we can compare them in a single visual.\n" + ], + "metadata": { + "id": "BMlNwrSytRdX" + } + }, + { + "cell_type": "code", + "source": [ + "all_results = {\n", + " \"Baseline\": base_results,\n", + " \"DeepCache\": smashed_results,\n", + " \"torch.compile\": compiled_results,\n", + "}\n", + "data = {name: {r.name: r.result for r in res} for name, res in all_results.items()}\n", + "\n", + "# Convert to more readable units for small workloads\n", + "metrics = {\n", + " \"Inference time (s)\": (\"total_time\", 1e-3), # ms -> s\n", + " \"Energy (Wh)\": (\"energy_consumed\", 1e3), # kWh -> Wh\n", + " \"CO2 emissions (g)\": (\"co2_emissions\", 1e3), # kg -> g\n", + " \"CLIP score\": (\"clip_score\", 1),\n", + "}\n", + "\n", + "names = list(all_results)\n", + "colors = [\"#8a8a8a\", \"#7c3aed\", \"#0d9488\"]\n", + "\n", + "fig, axes = plt.subplots(1, 4, figsize=(15, 4), layout=\"constrained\")\n", + "\n", + "for ax, (label, (key, scale)) in zip(axes, metrics.items()):\n", + " vals = [data[name][key] * scale for name in names]\n", + " bars = ax.bar(names, vals, color=colors)\n", + " labels = [f\"{v:.3f}\" if i == 0 else f\"{v:.3f}\\n({(v / vals[0] - 1) * 100:+.1f}%)\"\n", + " for i, v in enumerate(vals)]\n", + " ax.bar_label(bars, labels=labels, fontsize=9)\n", + " ax.set_ylim(0, max(vals) * 1.3)\n", + " ax.set_title(label)\n", + "\n", + "fig.suptitle(\"Benchmark metrics vs. baseline\")\n", + "plt.show()" + ], + "metadata": { + "id": "zEAcXrrCtJ87" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### 11. Takeaway\n", + "\n", + "All three sustainability metrics move together: less inference time means proportionally less energy and CO2. DeepCache achieves this by skipping redundant UNet computation, while torch.compile runs the same computation with faster kernels, so its gains depend on the hardware.\n", + "\n", + "CLIP score shows a slight drop for DeepCache, hinting at a small quality tradeoff even in this limited run. For a stricter quality comparison, see the [CMMD evaluation tutorial](./evaluation_agent_cmmd.ipynb)." + ], + "metadata": { + "id": "FhhTk9tK8Uhr" + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + }, + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "accelerator": "GPU" + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 144a79e3572c2141f49348440d7d5a5cc4e015fb Mon Sep 17 00:00:00 2001 From: Zini Chakraborty Date: Wed, 8 Jul 2026 01:50:41 -0700 Subject: [PATCH 2/4] docs: run ruff on sustainability tutorial --- .../evaluation_agent_sustainability.ipynb | 855 +++++++++--------- 1 file changed, 429 insertions(+), 426 deletions(-) diff --git a/docs/tutorials/evaluation_agent_sustainability.ipynb b/docs/tutorials/evaluation_agent_sustainability.ipynb index 57c25134..d43aa3ab 100644 --- a/docs/tutorials/evaluation_agent_sustainability.ipynb +++ b/docs/tutorials/evaluation_agent_sustainability.ipynb @@ -1,430 +1,433 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "zYI71djJxM63" - }, - "source": [ - "# Evaluating Sustainability using EvaluationAgent" - ] - }, - { - "cell_type": "raw", - "metadata": { - "vscode": { - "languageId": "raw" - }, - "id": "FZ-4_M4fxM64" - }, - "source": [ - "\n", - " \"Open\n", - "" - ] - }, - { - "cell_type": "markdown", - "source": [ - "This tutorial demonstrates how to use the `pruna` package to evaluate the sustainability of a model. Image generation is among the most energy-intensive inference workloads. Compression methods promise to reduce this, but their savings vary with hardware and workload, so the only way to know what a method actually saves *for you* is to measure it. Sustainability benchmarks make those savings visible and comparable.\n", - "\n", - "We will use the `stable-diffusion-v1-5` model and a subset of the `LAION256` dataset, comparing a baseline against two optimization methods (`deepcache` and `torch_compile`). Any execution times given below are measured on a T4 GPU." - ], - "metadata": { - "id": "1odA2-O0aztf" - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "HfEXSjYWxM64" - }, - "outputs": [], - "source": [ - "# if you are not running the latest version of this tutorial, make sure to install the matching version of pruna\n", - "# the following command will install the latest version of pruna\n", - "%pip install pruna" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "OCoHdvckxM64" - }, - "source": [ - "### 1. Loading the model\n", - "\n", - "First, load your model." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "4PMNwfOOxM64" - }, - "outputs": [], - "source": [ - "import torch\n", - "from diffusers import AutoPipelineForText2Image\n", - "\n", - "from pruna.engine.pruna_model import PrunaModel\n", - "\n", - "pipe = AutoPipelineForText2Image.from_pretrained(\n", - " \"stable-diffusion-v1-5/stable-diffusion-v1-5\",\n", - " torch_dtype=torch.float16,\n", - " use_safetensors=True,\n", - ")\n", - "pipe = pipe.to(\"cuda\")\n", - "model = PrunaModel(pipe)\n", - "pipe.set_progress_bar_config(disable=True)\n", - "\n", - "# Shared generation parameters, applied to every configuration so results are comparable\n", - "GEN_ARGS = {\"num_inference_steps\": 25, \"guidance_scale\": 7.5}" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Zgvuf3dZxM64" - }, - "source": [ - "### 2. Benchmark metrics\n", - "\n", - "`pruna` tracks three sustainability metrics:\n", - "\n", - "- **`total_time`**: wall-clock time to run the benchmark iterations (ms)\n", - "- **`energy_consumed`**: total energy drawn during inference (kWh)\n", - "- **`co2_emissions`**: estimated CO2-equivalent emissions based on energy consumed and hardware location (kg)\n", - "\n", - "We also include **`clip_score`**, a quality metric measuring how well generated images match their prompts, so we can check whether efficiency gains come at a quality cost.\n", - "\n", - "We will pass these metrics to the evaluation `Task` as a list of metric instances. For other ways to specify metrics, see the [evaluation documentation](https://docs.pruna.ai/en/stable/docs_pruna/user_manual/evaluate.html)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "yTBJuCTNxM65" - }, - "outputs": [], - "source": [ - "from pruna.evaluation.metrics import (\n", - " TotalTimeMetric, EnergyConsumedMetric, CO2EmissionsMetric, TorchMetricWrapper,\n", - ")\n", - "\n", - "request = [\n", - " TotalTimeMetric(n_iterations=10, n_warmup_iterations=3),\n", - " EnergyConsumedMetric(n_iterations=10, n_warmup_iterations=3),\n", - " CO2EmissionsMetric(n_iterations=10, n_warmup_iterations=3),\n", - " TorchMetricWrapper(\"clip_score\"),\n", - "]" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "vFhRH1YCxM65" - }, - "source": [ - "### 3. Create an EvaluationAgent and a Task\n", - "\n", - "Pruna's evaluation process uses a Task to define which metrics to calculate and provide the evaluation data. The EvaluationAgent then takes this Task and handles running the model inference, passing the inputs, ground truth, and predictions to each metric, and collecting the results.\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "wSIDHfEoxM65" - }, - "outputs": [], - "source": [ - "from pruna.data.pruna_datamodule import PrunaDataModule\n", - "from pruna.evaluation.evaluation_agent import EvaluationAgent\n", - "from pruna.evaluation.task import Task\n", - "\n", - "datamodule = PrunaDataModule.from_string(\"LAION256\")\n", - "datamodule.limit_datasets(10) # Quality metrics run over these 10 samples. Timing metrics benchmark a single batch\n", - "task = Task(request, datamodule)\n", - "eval_agent = EvaluationAgent(task)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "7tKFVEQPxM65" - }, - "source": [ - "### 4. Evaluate the baseline model\n", - "\n", - "We can evaluate a model by calling the `evaluate` method of the EvaluationAgent." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "wWvxYQvMxM65" - }, - "outputs": [], - "source": [ - "model.inference_handler.model_args.update(GEN_ARGS)\n", - "\n", - "base_results = eval_agent.evaluate(model)\n", - "for r in base_results:\n", - " print(f\"{r.name}: {r.result:.4g}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "KT_eDmagxM65" - }, - "source": [ - "### 5. Smash the model with DeepCache" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "XGcu7t-8xM65" - }, - "outputs": [], - "source": [ - "import copy\n", - "\n", - "from pruna import smash\n", - "from pruna.config.smash_config import SmashConfig\n", - "from pruna.engine.utils import safe_memory_cleanup\n", - "\n", - "smash_config = SmashConfig()\n", - "smash_config.add(dict(deepcache=True))\n", - "\n", - "pipe = pipe.to(\"cpu\")\n", - "safe_memory_cleanup()\n", - "\n", - "copy_pipe = copy.deepcopy(pipe).to(\"cuda\")\n", - "smashed_pipe = smash(copy_pipe, smash_config)\n", - "smashed_pipe.set_progress_bar_config(disable=True)\n", - "smashed_pipe.inference_handler.model_args.update(GEN_ARGS)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "_g5UNUW2xM65" - }, - "source": [ - "### 6. Evaluate the first smashed model (DeepCache)\n", - "\n", - "We now evaluate the smashed model by calling evaluate again." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "DBPyC0O4xM65" - }, - "outputs": [], - "source": [ - "smashed_results = eval_agent.evaluate(smashed_pipe)\n", - "for r in smashed_results:\n", - " print(f\"{r.name}: {r.result:.4g}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "fbtvUWW9xM65" - }, - "source": [ - "### 7. Analyze baseline vs DeepCache\n", - "\n", - "With both configurations evaluated on the same task, we can now compare them side by side. For time, energy, and CO2 a negative change is an improvement. For CLIP score, higher is better." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "M8baXC6axM65" - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "base = {r.name: r.result for r in base_results}\n", - "smashed = {r.name: r.result for r in smashed_results}\n", - "\n", - "metrics = {\n", - " \"Inference time (s)\": (\"total_time\", 1e-3), # ms -> s\n", - " \"Energy (Wh)\": (\"energy_consumed\", 1e3), # kWh -> Wh\n", - " \"CO2 emissions (g)\": (\"co2_emissions\", 1e3), # kg -> g\n", - " \"CLIP score\": (\"clip_score\", 1),\n", - "}\n", - "\n", - "fig, axes = plt.subplots(1, 4, figsize=(15, 4), layout=\"constrained\")\n", - "\n", - "for ax, (label, (key, scale)) in zip(axes, metrics.items()):\n", - " values = [base[key] * scale, smashed[key] * scale]\n", - " bars = ax.bar([\"Baseline\", \"DeepCache\"], values, color=[\"#8a8a8a\", \"#7c3aed\"])\n", - " change = (values[1] / values[0] - 1) * 100\n", - " ax.bar_label(bars, labels=[f\"{values[0]:.3f}\", f\"{values[1]:.3f}\\n({change:+.1f}%)\"], fontsize=9)\n", - " ax.set_ylim(0, max(values) * 1.3)\n", - " ax.set_title(label)\n", - "\n", - "fig.suptitle(\"Benchmark metrics: baseline vs. DeepCache\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "source": [ - "### 8. Smash the model with torch_compile" - ], - "metadata": { - "id": "lf5yG4hBsGr1" - } - }, - { - "cell_type": "code", - "source": [ - "# Free the DeepCache pipeline before building the next configuration\n", - "del smashed_pipe\n", - "safe_memory_cleanup()\n", - "\n", - "# Smash with torch.compile (start from a fresh copy of the original pipe)\n", - "compile_config = SmashConfig()\n", - "compile_config.add(dict(torch_compile=True))\n", - "\n", - "compile_pipe = smash(copy.deepcopy(pipe).to(\"cuda\"), compile_config)\n", - "compile_pipe.set_progress_bar_config(disable=True)\n", - "compile_pipe.inference_handler.model_args.update(GEN_ARGS)" - ], - "metadata": { - "id": "5KpMar6gsdH3" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "### 9. Evaluate the second smashed model (torch_compile)" - ], - "metadata": { - "id": "T6Igrkx1tR2Y" - } - }, - { - "cell_type": "code", - "source": [ - "compiled_results = eval_agent.evaluate(compile_pipe)\n", - "for r in compiled_results:\n", - " print(f\"{r.name}: {r.result:.4g}\")" - ], - "metadata": { - "id": "8v_mndBYtJPf" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "### 10. Analyze baseline vs DeepCache vs torch_compile\n", - "\n", - "With all three configurations evaluated on the same task, we can compare them in a single visual.\n" - ], - "metadata": { - "id": "BMlNwrSytRdX" - } - }, - { - "cell_type": "code", - "source": [ - "all_results = {\n", - " \"Baseline\": base_results,\n", - " \"DeepCache\": smashed_results,\n", - " \"torch.compile\": compiled_results,\n", - "}\n", - "data = {name: {r.name: r.result for r in res} for name, res in all_results.items()}\n", - "\n", - "# Convert to more readable units for small workloads\n", - "metrics = {\n", - " \"Inference time (s)\": (\"total_time\", 1e-3), # ms -> s\n", - " \"Energy (Wh)\": (\"energy_consumed\", 1e3), # kWh -> Wh\n", - " \"CO2 emissions (g)\": (\"co2_emissions\", 1e3), # kg -> g\n", - " \"CLIP score\": (\"clip_score\", 1),\n", - "}\n", - "\n", - "names = list(all_results)\n", - "colors = [\"#8a8a8a\", \"#7c3aed\", \"#0d9488\"]\n", - "\n", - "fig, axes = plt.subplots(1, 4, figsize=(15, 4), layout=\"constrained\")\n", - "\n", - "for ax, (label, (key, scale)) in zip(axes, metrics.items()):\n", - " vals = [data[name][key] * scale for name in names]\n", - " bars = ax.bar(names, vals, color=colors)\n", - " labels = [f\"{v:.3f}\" if i == 0 else f\"{v:.3f}\\n({(v / vals[0] - 1) * 100:+.1f}%)\"\n", - " for i, v in enumerate(vals)]\n", - " ax.bar_label(bars, labels=labels, fontsize=9)\n", - " ax.set_ylim(0, max(vals) * 1.3)\n", - " ax.set_title(label)\n", - "\n", - "fig.suptitle(\"Benchmark metrics vs. baseline\")\n", - "plt.show()" - ], - "metadata": { - "id": "zEAcXrrCtJ87" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "### 11. Takeaway\n", - "\n", - "All three sustainability metrics move together: less inference time means proportionally less energy and CO2. DeepCache achieves this by skipping redundant UNet computation, while torch.compile runs the same computation with faster kernels, so its gains depend on the hardware.\n", - "\n", - "CLIP score shows a slight drop for DeepCache, hinting at a small quality tradeoff even in this limited run. For a stricter quality comparison, see the [CMMD evaluation tutorial](./evaluation_agent_cmmd.ipynb)." - ], - "metadata": { - "id": "FhhTk9tK8Uhr" - } + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "zYI71djJxM63" + }, + "source": [ + "# Evaluating Sustainability using EvaluationAgent" + ] + }, + { + "cell_type": "raw", + "metadata": { + "id": "FZ-4_M4fxM64", + "vscode": { + "languageId": "raw" } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.11" - }, - "colab": { - "provenance": [], - "gpuType": "T4" - }, - "accelerator": "GPU" + }, + "source": [ + "\n", + " \"Open\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1odA2-O0aztf" + }, + "source": [ + "This tutorial demonstrates how to use the `pruna` package to evaluate the sustainability of a model. Image generation is among the most energy-intensive inference workloads. Compression methods promise to reduce this, but their savings vary with hardware and workload, so the only way to know what a method actually saves *for you* is to measure it. Sustainability benchmarks make those savings visible and comparable.\n", + "\n", + "We will use the `stable-diffusion-v1-5` model and a subset of the `LAION256` dataset, comparing a baseline against two optimization methods (`deepcache` and `torch_compile`). Any execution times given below are measured on a T4 GPU." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "HfEXSjYWxM64" + }, + "outputs": [], + "source": [ + "# if you are not running the latest version of this tutorial, make sure to install the matching version of pruna\n", + "# the following command will install the latest version of pruna\n", + "%pip install pruna" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OCoHdvckxM64" + }, + "source": [ + "### 1. Loading the model\n", + "\n", + "First, load your model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4PMNwfOOxM64" + }, + "outputs": [], + "source": [ + "import torch\n", + "from diffusers import AutoPipelineForText2Image\n", + "\n", + "from pruna.engine.pruna_model import PrunaModel\n", + "\n", + "pipe = AutoPipelineForText2Image.from_pretrained(\n", + " \"stable-diffusion-v1-5/stable-diffusion-v1-5\",\n", + " torch_dtype=torch.float16,\n", + " use_safetensors=True,\n", + ")\n", + "pipe = pipe.to(\"cuda\")\n", + "model = PrunaModel(pipe)\n", + "pipe.set_progress_bar_config(disable=True)\n", + "\n", + "# Shared generation parameters, applied to every configuration so results are comparable\n", + "GEN_ARGS = {\"num_inference_steps\": 25, \"guidance_scale\": 7.5}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Zgvuf3dZxM64" + }, + "source": [ + "### 2. Benchmark metrics\n", + "\n", + "`pruna` tracks three sustainability metrics:\n", + "\n", + "- **`total_time`**: wall-clock time to run the benchmark iterations (ms)\n", + "- **`energy_consumed`**: total energy drawn during inference (kWh)\n", + "- **`co2_emissions`**: estimated CO2-equivalent emissions based on energy consumed and hardware location (kg)\n", + "\n", + "We also include **`clip_score`**, a quality metric measuring how well generated images match their prompts, so we can check whether efficiency gains come at a quality cost.\n", + "\n", + "We will pass these metrics to the evaluation `Task` as a list of metric instances. For other ways to specify metrics, see the [evaluation documentation](https://docs.pruna.ai/en/stable/docs_pruna/user_manual/evaluate.html)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "yTBJuCTNxM65" + }, + "outputs": [], + "source": [ + "from pruna.evaluation.metrics import (\n", + " CO2EmissionsMetric,\n", + " EnergyConsumedMetric,\n", + " TorchMetricWrapper,\n", + " TotalTimeMetric,\n", + ")\n", + "\n", + "request = [\n", + " TotalTimeMetric(n_iterations=10, n_warmup_iterations=3),\n", + " EnergyConsumedMetric(n_iterations=10, n_warmup_iterations=3),\n", + " CO2EmissionsMetric(n_iterations=10, n_warmup_iterations=3),\n", + " TorchMetricWrapper(\"clip_score\"),\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vFhRH1YCxM65" + }, + "source": [ + "### 3. Create an EvaluationAgent and a Task\n", + "\n", + "Pruna's evaluation process uses a Task to define which metrics to calculate and provide the evaluation data. The EvaluationAgent then takes this Task and handles running the model inference, passing the inputs, ground truth, and predictions to each metric, and collecting the results.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wSIDHfEoxM65" + }, + "outputs": [], + "source": [ + "from pruna.data.pruna_datamodule import PrunaDataModule\n", + "from pruna.evaluation.evaluation_agent import EvaluationAgent\n", + "from pruna.evaluation.task import Task\n", + "\n", + "datamodule = PrunaDataModule.from_string(\"LAION256\")\n", + "datamodule.limit_datasets(10) # Quality metrics run over these 10 samples. Timing metrics benchmark a single batch\n", + "task = Task(request, datamodule)\n", + "eval_agent = EvaluationAgent(task)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7tKFVEQPxM65" + }, + "source": [ + "### 4. Evaluate the baseline model\n", + "\n", + "We can evaluate a model by calling the `evaluate` method of the EvaluationAgent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wWvxYQvMxM65" + }, + "outputs": [], + "source": [ + "model.inference_handler.model_args.update(GEN_ARGS)\n", + "\n", + "base_results = eval_agent.evaluate(model)\n", + "for r in base_results:\n", + " print(f\"{r.name}: {r.result:.4g}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KT_eDmagxM65" + }, + "source": [ + "### 5. Smash the model with DeepCache" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "XGcu7t-8xM65" + }, + "outputs": [], + "source": [ + "import copy\n", + "\n", + "from pruna import smash\n", + "from pruna.config.smash_config import SmashConfig\n", + "from pruna.engine.utils import safe_memory_cleanup\n", + "\n", + "smash_config = SmashConfig()\n", + "smash_config.add(dict(deepcache=True))\n", + "\n", + "pipe = pipe.to(\"cpu\")\n", + "safe_memory_cleanup()\n", + "\n", + "copy_pipe = copy.deepcopy(pipe).to(\"cuda\")\n", + "smashed_pipe = smash(copy_pipe, smash_config)\n", + "smashed_pipe.set_progress_bar_config(disable=True)\n", + "smashed_pipe.inference_handler.model_args.update(GEN_ARGS)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_g5UNUW2xM65" + }, + "source": [ + "### 6. Evaluate the first smashed model (DeepCache)\n", + "\n", + "We now evaluate the smashed model by calling evaluate again." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "DBPyC0O4xM65" + }, + "outputs": [], + "source": [ + "smashed_results = eval_agent.evaluate(smashed_pipe)\n", + "for r in smashed_results:\n", + " print(f\"{r.name}: {r.result:.4g}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fbtvUWW9xM65" + }, + "source": [ + "### 7. Analyze baseline vs DeepCache\n", + "\n", + "With both configurations evaluated on the same task, we can now compare them side by side. For time, energy, and CO2 a negative change is an improvement. For CLIP score, higher is better." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "M8baXC6axM65" + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "base = {r.name: r.result for r in base_results}\n", + "smashed = {r.name: r.result for r in smashed_results}\n", + "\n", + "metrics = {\n", + " \"Inference time (s)\": (\"total_time\", 1e-3), # ms -> s\n", + " \"Energy (Wh)\": (\"energy_consumed\", 1e3), # kWh -> Wh\n", + " \"CO2 emissions (g)\": (\"co2_emissions\", 1e3), # kg -> g\n", + " \"CLIP score\": (\"clip_score\", 1),\n", + "}\n", + "\n", + "fig, axes = plt.subplots(1, 4, figsize=(15, 4), layout=\"constrained\")\n", + "\n", + "for ax, (label, (key, scale)) in zip(axes, metrics.items()):\n", + " values = [base[key] * scale, smashed[key] * scale]\n", + " bars = ax.bar([\"Baseline\", \"DeepCache\"], values, color=[\"#8a8a8a\", \"#7c3aed\"])\n", + " change = (values[1] / values[0] - 1) * 100\n", + " ax.bar_label(bars, labels=[f\"{values[0]:.3f}\", f\"{values[1]:.3f}\\n({change:+.1f}%)\"], fontsize=9)\n", + " ax.set_ylim(0, max(values) * 1.3)\n", + " ax.set_title(label)\n", + "\n", + "fig.suptitle(\"Benchmark metrics: baseline vs. DeepCache\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lf5yG4hBsGr1" + }, + "source": [ + "### 8. Smash the model with torch_compile" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "5KpMar6gsdH3" + }, + "outputs": [], + "source": [ + "# Free the DeepCache pipeline before building the next configuration\n", + "del smashed_pipe\n", + "safe_memory_cleanup()\n", + "\n", + "# Smash with torch.compile (start from a fresh copy of the original pipe)\n", + "compile_config = SmashConfig()\n", + "compile_config.add(dict(torch_compile=True))\n", + "\n", + "compile_pipe = smash(copy.deepcopy(pipe).to(\"cuda\"), compile_config)\n", + "compile_pipe.set_progress_bar_config(disable=True)\n", + "compile_pipe.inference_handler.model_args.update(GEN_ARGS)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "T6Igrkx1tR2Y" + }, + "source": [ + "### 9. Evaluate the second smashed model (torch_compile)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "8v_mndBYtJPf" + }, + "outputs": [], + "source": [ + "compiled_results = eval_agent.evaluate(compile_pipe)\n", + "for r in compiled_results:\n", + " print(f\"{r.name}: {r.result:.4g}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BMlNwrSytRdX" + }, + "source": [ + "### 10. Analyze baseline vs DeepCache vs torch_compile\n", + "\n", + "With all three configurations evaluated on the same task, we can compare them in a single visual.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zEAcXrrCtJ87" + }, + "outputs": [], + "source": [ + "all_results = {\n", + " \"Baseline\": base_results,\n", + " \"DeepCache\": smashed_results,\n", + " \"torch.compile\": compiled_results,\n", + "}\n", + "data = {name: {r.name: r.result for r in res} for name, res in all_results.items()}\n", + "\n", + "# Convert to more readable units for small workloads\n", + "metrics = {\n", + " \"Inference time (s)\": (\"total_time\", 1e-3), # ms -> s\n", + " \"Energy (Wh)\": (\"energy_consumed\", 1e3), # kWh -> Wh\n", + " \"CO2 emissions (g)\": (\"co2_emissions\", 1e3), # kg -> g\n", + " \"CLIP score\": (\"clip_score\", 1),\n", + "}\n", + "\n", + "names = list(all_results)\n", + "colors = [\"#8a8a8a\", \"#7c3aed\", \"#0d9488\"]\n", + "\n", + "fig, axes = plt.subplots(1, 4, figsize=(15, 4), layout=\"constrained\")\n", + "\n", + "for ax, (label, (key, scale)) in zip(axes, metrics.items()):\n", + " vals = [data[name][key] * scale for name in names]\n", + " bars = ax.bar(names, vals, color=colors)\n", + " labels = [f\"{v:.3f}\" if i == 0 else f\"{v:.3f}\\n({(v / vals[0] - 1) * 100:+.1f}%)\"\n", + " for i, v in enumerate(vals)]\n", + " ax.bar_label(bars, labels=labels, fontsize=9)\n", + " ax.set_ylim(0, max(vals) * 1.3)\n", + " ax.set_title(label)\n", + "\n", + "fig.suptitle(\"Benchmark metrics vs. baseline\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FhhTk9tK8Uhr" + }, + "source": [ + "### 11. Takeaway\n", + "\n", + "All three sustainability metrics move together: less inference time means proportionally less energy and CO2. DeepCache achieves this by skipping redundant UNet computation, while torch.compile runs the same computation with faster kernels, so its gains depend on the hardware.\n", + "\n", + "CLIP score shows a slight drop for DeepCache, hinting at a small quality tradeoff even in this limited run. For a stricter quality comparison, see the [CMMD evaluation tutorial](./evaluation_agent_cmmd.ipynb)." + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 0 + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 } From 77cf274e7cc2242d0d36fca6e9e3bacdc626d670 Mon Sep 17 00:00:00 2001 From: Zini Chakraborty Date: Wed, 8 Jul 2026 01:58:43 -0700 Subject: [PATCH 3/4] docs: register sustainability tutorial in index --- docs/tutorials/index.rst | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/docs/tutorials/index.rst b/docs/tutorials/index.rst index 142b6fcb..12f28a5c 100644 --- a/docs/tutorials/index.rst +++ b/docs/tutorials/index.rst @@ -58,6 +58,12 @@ These tutorials will guide you through the process of using |pruna| to optimize ``Evaluate`` image generation quality with ``CMMD`` and ``EvaluationAgent``. + .. grid-item-card:: Evaluating Sustainability using EvaluationAgent + :text-align: center + :link: ./evaluation_agent_sustainability.ipynb + + ``Evaluate`` energy, CO2, and time with ``EvaluationAgent``, comparing ``deepcache`` and ``torch_compile`` against a baseline. + .. grid-item-card:: x2 smaller Sana diffusers in action :text-align: center :link: ./sana_diffusers_int8.ipynb @@ -125,4 +131,3 @@ These tutorials will guide you through the process of using |pruna| to optimize :glob: ./* - From 2a91c90aad7b5d2f413e55ddc1a8485999e2bf57 Mon Sep 17 00:00:00 2001 From: Zini Chakraborty Date: Thu, 16 Jul 2026 20:14:27 -0700 Subject: [PATCH 4/4] docs: address review feedback on sustainability tutorial --- .../evaluation_agent_sustainability.ipynb | 119 ++++++++++++++---- 1 file changed, 92 insertions(+), 27 deletions(-) diff --git a/docs/tutorials/evaluation_agent_sustainability.ipynb b/docs/tutorials/evaluation_agent_sustainability.ipynb index d43aa3ab..62a50899 100644 --- a/docs/tutorials/evaluation_agent_sustainability.ipynb +++ b/docs/tutorials/evaluation_agent_sustainability.ipynb @@ -6,7 +6,7 @@ "id": "zYI71djJxM63" }, "source": [ - "# Evaluating Sustainability using EvaluationAgent" + "# Evaluating Sustainability using EvaluationAgent" ] }, { @@ -29,9 +29,25 @@ "id": "1odA2-O0aztf" }, "source": [ - "This tutorial demonstrates how to use the `pruna` package to evaluate the sustainability of a model. Image generation is among the most energy-intensive inference workloads. Compression methods promise to reduce this, but their savings vary with hardware and workload, so the only way to know what a method actually saves *for you* is to measure it. Sustainability benchmarks make those savings visible and comparable.\n", + "| Component | Details |\n", + "|-----------|---------|\n", + "| **Goal** | Show how to evaluate the sustainability of optimization algorithms by measuring inference time, energy consumption, CO₂ emissions, and quality trade-offs. |\n", + "| **Model** | [stable-diffusion-v1-5/stable-diffusion-v1-5](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) |\n", + "| **Dataset** | [LAION256](https://huggingface.co/datasets/nannullna/laion_subset) (10-sample subset) |\n", + "| **Device** | 1 x T4 (16GB) |\n", + "| **Optimization Algorithms** | cacher(deepcache), compiler(torch_compile) |\n", + "| **Evaluation Metrics** | `total_time`, `energy_consumed`, `co2_emissions`, `clip_score` |" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hXDK5Mt1o6qc" + }, + "source": [ + "## Getting Started\n", "\n", - "We will use the `stable-diffusion-v1-5` model and a subset of the `LAION256` dataset, comparing a baseline against two optimization methods (`deepcache` and `torch_compile`). Any execution times given below are measured on a T4 GPU." + "To install the required dependencies, you can run the following command:" ] }, { @@ -42,20 +58,27 @@ }, "outputs": [], "source": [ - "# if you are not running the latest version of this tutorial, make sure to install the matching version of pruna\n", - "# the following command will install the latest version of pruna\n", "%pip install pruna" ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "ixOOuXkao6qd" + }, + "source": [ + "For more information about how to install Pruna, please refer to the [Installation](https://docs.pruna.ai/en/stable/setup/install.html) page." + ] + }, { "cell_type": "markdown", "metadata": { "id": "OCoHdvckxM64" }, "source": [ - "### 1. Loading the model\n", + "## 1. Load the Model\n", "\n", - "First, load your model." + "First, we load the model. We use [stable-diffusion-v1-5](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5), one of the most widely used text-to-image diffusion models: it is small enough to run on a T4 GPU while still being representative of the compute and energy profile of real image-generation workloads. Feel free to swap in any other diffusion model from Hugging Face." ] }, { @@ -90,13 +113,13 @@ "id": "Zgvuf3dZxM64" }, "source": [ - "### 2. Benchmark metrics\n", + "## 2. Define the Evaluation Metrics\n", "\n", "`pruna` tracks three sustainability metrics:\n", "\n", "- **`total_time`**: wall-clock time to run the benchmark iterations (ms)\n", "- **`energy_consumed`**: total energy drawn during inference (kWh)\n", - "- **`co2_emissions`**: estimated CO2-equivalent emissions based on energy consumed and hardware location (kg)\n", + "- **`co2_emissions`**: estimated CO₂-equivalent emissions based on energy consumed and hardware location (kg)\n", "\n", "We also include **`clip_score`**, a quality metric measuring how well generated images match their prompts, so we can check whether efficiency gains come at a quality cost.\n", "\n", @@ -132,11 +155,9 @@ "id": "vFhRH1YCxM65" }, "source": [ - "### 3. Create an EvaluationAgent and a Task\n", + "## 3. Create an EvaluationAgent and a Task\n", "\n", - "Pruna's evaluation process uses a Task to define which metrics to calculate and provide the evaluation data. The EvaluationAgent then takes this Task and handles running the model inference, passing the inputs, ground truth, and predictions to each metric, and collecting the results.\n", - "\n", - "\n" + "Pruna's evaluation process uses a Task to define which metrics to calculate and provide the evaluation data. The EvaluationAgent then takes this Task and handles running the model inference, passing the inputs, ground truth, and predictions to each metric, and collecting the results." ] }, { @@ -163,7 +184,7 @@ "id": "7tKFVEQPxM65" }, "source": [ - "### 4. Evaluate the baseline model\n", + "## 4. Evaluate the Baseline Model\n", "\n", "We can evaluate a model by calling the `evaluate` method of the EvaluationAgent." ] @@ -189,7 +210,9 @@ "id": "KT_eDmagxM65" }, "source": [ - "### 5. Smash the model with DeepCache" + "## 5. Smash the Model with DeepCache\n", + "\n", + "[DeepCache](https://docs.pruna.ai/en/stable/compression.html#deepcache) is a caching algorithm for diffusion models: it exploits the redundancy between consecutive denoising steps by caching intermediate UNet feature maps and reusing them in later steps, skipping part of the computation. Since the GPU does less work per image, we expect inference time (and with it energy consumption and CO₂ emissions) to drop, possibly at a small cost in image quality." ] }, { @@ -224,7 +247,7 @@ "id": "_g5UNUW2xM65" }, "source": [ - "### 6. Evaluate the first smashed model (DeepCache)\n", + "## 6. Evaluate the Smashed Model (DeepCache)\n", "\n", "We now evaluate the smashed model by calling evaluate again." ] @@ -248,9 +271,9 @@ "id": "fbtvUWW9xM65" }, "source": [ - "### 7. Analyze baseline vs DeepCache\n", + "## 7. Analyze Baseline vs. DeepCache\n", "\n", - "With both configurations evaluated on the same task, we can now compare them side by side. For time, energy, and CO2 a negative change is an improvement. For CLIP score, higher is better." + "With both configurations evaluated on the same task, we can now compare them side by side. For time, energy, and CO₂ a negative change is an improvement. For CLIP score, higher is better." ] }, { @@ -259,7 +282,18 @@ "metadata": { "id": "M8baXC6axM65" }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -287,13 +321,24 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "jRn8xPlotA19" + }, + "source": [ + "DeepCache roughly halves inference time (-46%) and cuts energy consumption and CO₂ emissions by about 38%, at the cost of a 2.4% drop in CLIP score." + ] + }, { "cell_type": "markdown", "metadata": { "id": "lf5yG4hBsGr1" }, "source": [ - "### 8. Smash the model with torch_compile" + "## 8. Smash the Model with torch_compile\n", + "\n", + "In contrast to DeepCache, [torch_compile](https://docs.pruna.ai/en/stable/compression.html#torch-compile) does not skip any computation: it compiles the model into optimized GPU kernels, so the exact same work runs faster. The generated images stay essentially identical, so quality is unaffected, but because the savings come purely from better kernel execution, how much time, energy, and CO₂ you save depends on your hardware." ] }, { @@ -323,7 +368,7 @@ "id": "T6Igrkx1tR2Y" }, "source": [ - "### 9. Evaluate the second smashed model (torch_compile)" + "## 9. Evaluate the Smashed Model (torch_compile)" ] }, { @@ -345,9 +390,9 @@ "id": "BMlNwrSytRdX" }, "source": [ - "### 10. Analyze baseline vs DeepCache vs torch_compile\n", + "## 10. Analyze Baseline vs. DeepCache vs. torch_compile\n", "\n", - "With all three configurations evaluated on the same task, we can compare them in a single visual.\n" + "With all three configurations evaluated on the same task, we can compare them in a single visual." ] }, { @@ -356,7 +401,18 @@ "metadata": { "id": "zEAcXrrCtJ87" }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "all_results = {\n", " \"Baseline\": base_results,\n", @@ -391,17 +447,26 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "kQm2xPlotB25" + }, + "source": [ + "DeepCache delivers the largest savings but with a small quality dip, while torch.compile saves less (16% time, 10% energy/CO₂) yet leaves quality untouched (CLIP score +0.9%)." + ] + }, { "cell_type": "markdown", "metadata": { "id": "FhhTk9tK8Uhr" }, "source": [ - "### 11. Takeaway\n", + "## Conclusions\n", "\n", - "All three sustainability metrics move together: less inference time means proportionally less energy and CO2. DeepCache achieves this by skipping redundant UNet computation, while torch.compile runs the same computation with faster kernels, so its gains depend on the hardware.\n", + "All three sustainability metrics move in the same direction: less inference time means less energy consumption and CO₂ emissions. In this workflow, DeepCache cuts inference time by about 46%, and energy and CO₂ by about 38% because baseline power draw (such as RAM and idle GPU power) is consumed regardless of how fast the computation runs. For torch.compile, inference time is cut by 16% while energy and CO₂ are cut by 10%. DeepCache achieves this by skipping redundant UNet computation, while torch.compile runs the same computation with faster kernels, so its gains depend on the hardware.\n", "\n", - "CLIP score shows a slight drop for DeepCache, hinting at a small quality tradeoff even in this limited run. For a stricter quality comparison, see the [CMMD evaluation tutorial](./evaluation_agent_cmmd.ipynb)." + "CLIP score shows a slight drop for DeepCache, hinting at a small quality tradeoff even in this limited run. For another comparison, see the [CMMD evaluation tutorial](./evaluation_agent_cmmd.ipynb)." ] } ],