Upload folder using huggingface_hub

vae-compilation/benchmark_pixart.py

@@ -0,0 +1,187 @@
+import torch
+
+torch.set_float32_matmul_precision("high")
+
+import torch.utils.benchmark as benchmark
+from diffusers import DiffusionPipeline
+import gc
+
+from torchao.quantization import (
+    int4_weight_only,
+    int8_weight_only,
+    int8_dynamic_activation_int8_weight,
+    quantize_,
+    autoquant,
+)
+from torchao.float8.inference import ActivationCasting, QuantConfig, quantize_to_float8
+from torchao.prototype.quant_llm import fp6_llm_weight_only
+from torchao.sparsity import sparsify_, int8_dynamic_activation_int8_semi_sparse_weight
+from tabulate import tabulate
+import argparse
+import json
+
+
+PROMPT = "Eiffel Tower was Made up of more than 2 million translucent straws to look like a cloud, with the bell tower at the top of the building, Michel installed huge foam-making machines in the forest to blow huge amounts of unpredictable wet clouds in the building's classic architecture."
+PREFIXES = {
+    "stabilityai/stable-diffusion-3-medium-diffusers": "sd3",
+    "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS": "pixart",
+    "fal/AuraFlow": "auraflow",
+}
+
+
+def flush():
+    gc.collect()
+    torch.cuda.empty_cache()
+    torch.cuda.reset_max_memory_allocated()
+    torch.cuda.reset_peak_memory_stats()
+
+
+def bytes_to_giga_bytes(bytes):
+    return f"{(bytes / 1024 / 1024 / 1024):.3f}"
+
+
+def benchmark_fn(f, *args, **kwargs):
+    t0 = benchmark.Timer(
+        stmt="f(*args, **kwargs)",
+        globals={"args": args, "kwargs": kwargs, "f": f},
+        num_threads=torch.get_num_threads(),
+    )
+    return f"{(t0.blocked_autorange().mean):.3f}"
+
+
+def load_pipeline(
+    ckpt_id: str,
+    fuse_attn_projections: bool,
+    compile: bool,
+    quantization: str,
+    sparsify: bool,
+) -> DiffusionPipeline:
+    pipeline = DiffusionPipeline.from_pretrained(ckpt_id, torch_dtype=torch.bfloat16).to("cuda")
+
+    if fuse_attn_projections:
+        pipeline.transformer.fuse_qkv_projections()
+        pipeline.vae.fuse_qkv_projections()
+
+    if quantization == "autoquant" and compile:
+        pipeline.transformer.to(memory_format=torch.channels_last)
+        pipeline.transformer = torch.compile(pipeline.transformer, mode="max-autotune", fullgraph=True)
+        pipeline.vae.to(memory_format=torch.channels_last)
+        pipeline.vae.decode = torch.compile(pipeline.vae.decode, mode="max-autotune", fullgraph=True)
+
+    if not sparsify:
+        if quantization == "int8dq":
+            quantize_(pipeline.transformer, int8_dynamic_activation_int8_weight())
+            quantize_(pipeline.vae, int8_dynamic_activation_int8_weight())
+        elif quantization == "int8wo":
+            quantize_(pipeline.transformer, int8_weight_only())
+            quantize_(pipeline.vae, int8_weight_only())
+        elif quantization == "int4wo":
+            quantize_(pipeline.transformer, int4_weight_only())
+            quantize_(pipeline.vae, int4_weight_only())
+        elif quantization == "fp6":
+            quantize_(pipeline.transformer, fp6_llm_weight_only())
+            quantize_(pipeline.vae, fp6_llm_weight_only())
+        elif quantization == "fp8":
+            pipeline.transformer = quantize_to_float8(pipeline.transformer, QuantConfig(ActivationCasting.DYNAMIC))
+            pipeline.vae = quantize_to_float8(pipeline.vae, QuantConfig(ActivationCasting.DYNAMIC))
+        elif quantization == "autoquant":
+            pipeline.transformer = autoquant(pipeline.transformer)
+            pipeline.vae = autoquant(pipeline.vae)
+
+    if sparsify:
+        sparsify_(pipeline.transformer, int8_dynamic_activation_int8_semi_sparse_weight())
+        sparsify_(pipeline.vae, int8_dynamic_activation_int8_semi_sparse_weight())
+
+    if quantization != "autoquant" and compile:
+        pipeline.transformer.to(memory_format=torch.channels_last)
+        pipeline.transformer = torch.compile(pipeline.transformer, mode="max-autotune", fullgraph=True)
+        pipeline.vae.to(memory_format=torch.channels_last)
+        pipeline.vae.decode = torch.compile(pipeline.vae.decode, mode="max-autotune", fullgraph=True)
+
+    pipeline.set_progress_bar_config(disable=True)
+    return pipeline
+
+
+def run_inference(pipe, batch_size):
+    _ = pipe(
+        prompt=PROMPT,
+        num_images_per_prompt=batch_size,
+        generator=torch.manual_seed(2024),
+    )
+
+
+def pretty_print_results(results, precision: int = 6):
+    def format_value(value):
+        if isinstance(value, float):
+            return f"{value:.{precision}f}"
+        return value
+
+    filtered_table = {k: format_value(v) for k, v in results.items()}
+    print(tabulate([filtered_table], headers="keys", tablefmt="pipe", stralign="center"))
+
+
+def run_benchmark(pipeline, args):
+    for _ in range(5):
+        run_inference(pipeline, batch_size=args.batch_size)
+
+    time = benchmark_fn(run_inference, pipeline, args.batch_size)
+    torch.cuda.empty_cache()
+    memory = bytes_to_giga_bytes(torch.cuda.memory_allocated())  # in GBs.
+
+    info = dict(
+        ckpt_id=args.ckpt_id,
+        batch_size=args.batch_size,
+        fuse=args.fuse_attn_projections,
+        compile=args.compile,
+        quantization=args.quantization,
+        sparsify=args.sparsify,
+        memory=memory,
+        time=time,
+    )
+
+    pretty_print_results(info)
+    return info
+
+
+def serialize_artifacts(info: dict, pipeline, args):
+    ckpt_id = PREFIXES[args.ckpt_id]
+    prefix = f"ckpt@{ckpt_id}-bs@{args.batch_size}-fuse@{args.fuse_attn_projections}-compile@{args.compile}-quant@{args.quantization}-sparsify@{args.sparsify}"
+    info_file = f"{prefix}_info.json"
+    with open(info_file, "w") as f:
+        json.dump(info, f)
+
+    image = pipeline(
+        prompt=PROMPT,
+        num_images_per_prompt=args.batch_size,
+        generator=torch.manual_seed(0),
+    ).images[0]
+    image.save(f"{prefix}.png")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--ckpt_id", default="PixArt-alpha/PixArt-Sigma-XL-2-1024-MS", type=str)
+    parser.add_argument("--fuse_attn_projections", action="store_true")
+    parser.add_argument("--compile", action="store_true")
+    parser.add_argument(
+        "--quantization",
+        default="None",
+        choices=["int8dq", "int8wo", "int4wo", "autoquant", "fp6", "fp8", "None"],
+        help="Which quantization technique to apply",
+    )
+    parser.add_argument("--sparsify", action="store_true")
+    parser.add_argument("--batch_size", default=1, type=int, choices=[1, 4, 8])
+    args = parser.parse_args()
+
+    flush()
+
+    pipeline = load_pipeline(
+        ckpt_id=args.ckpt_id,
+        fuse_attn_projections=args.fuse_attn_projections,
+        compile=args.compile,
+        quantization=args.quantization,
+        sparsify=args.sparsify,
+    )
+
+    info = run_benchmark(pipeline, args)
+    serialize_artifacts(info, pipeline, args)

vae-compilation/exp.slurm

@@ -0,0 +1,27 @@
+#!/bin/bash
+#SBATCH --job-name=torchao
+#SBATCH --nodes=1
+# Set the QoS
+#SBATCH --qos=high
+# set 5h for job wall time limit
+#SBATCH --time=05:00:00
+# activate the requeue option
+#SBATCH --requeue
+#SBATCH --ntasks-per-node=1
+#SBATCH --cpus-per-task=96
+#SBATCH --gres=gpu:8
+#SBATCH --mem=1999G
+#SBATCH --exclusive
+#SBATCH --partition=hopper-prod
+#SBATCH -o /fsx/sayak/logs/%x-%j.out
+
+set -xe
+
+module load cuda/12.1
+
+export NCCL_ASYNC_ERROR_HANDLING=1
+export LARGE_SCALE_TRAINING=1
+
+srun --wait=60 --kill-on-bad-exit=1 bash launch.sh
+
+echo "END TIME: $(date)"

vae-compilation/exp_autoquant.slurm

@@ -0,0 +1,28 @@
+#!/bin/bash
+#SBATCH --job-name=torchao
+#SBATCH --nodes=1
+# Set the QoS
+#SBATCH --qos=prod
+# set 5h for job wall time limit
+#SBATCH --time=05:00:00
+# activate the requeue option
+#SBATCH --requeue
+#SBATCH --ntasks-per-node=1
+#SBATCH --cpus-per-task=96
+#SBATCH --gres=gpu:8
+#SBATCH --mem=1999G
+#SBATCH --exclusive
+#SBATCH --partition=hopper-prod
+#SBATCH -o /fsx/sayak/logs/benchmark-%x-%j.out
+
+set -xe
+
+module load cuda/12.1
+
+export NCCL_ASYNC_ERROR_HANDLING=1
+export LARGE_SCALE_TRAINING=1
+export CUDA_VISIBLE_DEVICES=0
+
+srun --wait=60 --kill-on-bad-exit=1 bash launch_autoquant.sh
+
+echo "END TIME: $(date)"

vae-compilation/exp_fp8.slurm

@@ -0,0 +1,28 @@
+#!/bin/bash
+#SBATCH --job-name=torchao
+#SBATCH --nodes=1
+# Set the QoS
+#SBATCH --qos=prod
+# set 5h for job wall time limit
+#SBATCH --time=05:00:00
+# activate the requeue option
+#SBATCH --requeue
+#SBATCH --ntasks-per-node=1
+#SBATCH --cpus-per-task=96
+#SBATCH --gres=gpu:8
+#SBATCH --mem=1999G
+#SBATCH --exclusive
+#SBATCH --partition=hopper-prod
+#SBATCH -o /fsx/sayak/logs/benchmark-%x-%j.out
+
+set -xe
+
+module load cuda/12.1
+
+export NCCL_ASYNC_ERROR_HANDLING=1
+export LARGE_SCALE_TRAINING=1
+export CUDA_VISIBLE_DEVICES=0
+
+srun --wait=60 --kill-on-bad-exit=1 bash launch_fp8.sh
+
+echo "END TIME: $(date)"

vae-compilation/exp_profile.slurm

@@ -0,0 +1,28 @@
+#!/bin/bash
+#SBATCH --job-name=torchao
+#SBATCH --nodes=1
+# Set the QoS
+#SBATCH --qos=prod
+# set 5h for job wall time limit
+#SBATCH --time=05:00:00
+# activate the requeue option
+#SBATCH --requeue
+#SBATCH --ntasks-per-node=1
+#SBATCH --cpus-per-task=96
+#SBATCH --gres=gpu:8
+#SBATCH --mem=1999G
+#SBATCH --exclusive
+#SBATCH --partition=hopper-prod
+#SBATCH -o /fsx/sayak/logs/profile-%x-%j.out
+
+set -xe
+
+module load cuda/12.1
+
+export NCCL_ASYNC_ERROR_HANDLING=1
+export LARGE_SCALE_TRAINING=1
+export CUDA_VISIBLE_DEVICES=0
+
+srun --wait=60 --kill-on-bad-exit=1 bash launch_profile.sh
+
+echo "END TIME: $(date)"

vae-compilation/launch.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+
+# Possible values for each argument
+ckpt_ids=("PixArt-alpha/PixArt-Sigma-XL-2-1024-MS")
+fuse_attn_projections_flags=("" "--fuse_attn_projections")
+compile_flags=("" "--compile")
+# quantizations=("int8dq" "int8wo" "int4wo" "autoquant" "None" "fp6" "fp8")
+quantizations=("int8dq" "int8wo" "int4wo" "None" "fp6")
+sparsify_flags=("" "--sparsify")
+batch_sizes=(1 4 8)
+
+# Loop over all combinations
+for ckpt_id in "${ckpt_ids[@]}"; do
+  for quantization in "${quantizations[@]}"; do
+    # Determine the valid flags based on quantization value
+    if [ "$quantization" == "None" ]; then
+      sparsify_flags=("" "--sparsify")  # Enable sparsify
+      fuse_attn_projections_flags=("")  # Disable fuse_attn_projections
+    else
+      sparsify_flags=("")  # Disable sparsify
+      fuse_attn_projections_flags=("" "--fuse_attn_projections")  # Enable fuse_attn_projections
+    fi
+    
+    for fuse_attn_projections in "${fuse_attn_projections_flags[@]}"; do
+      for compile in "${compile_flags[@]}"; do
+        for sparsify in "${sparsify_flags[@]}"; do
+          for batch_size in "${batch_sizes[@]}"; do
+            # Construct the command
+            cmd="python3 benchmark_pixart.py --ckpt_id \"$ckpt_id\" $fuse_attn_projections $compile --quantization \"$quantization\" $sparsify --batch_size \"$batch_size\""
+            
+            # Echo the command
+            echo "Running command: $cmd"
+            
+            # Run the command
+            eval $cmd
+          done
+        done
+      done
+    done
+  done
+done

vae-compilation/launch_autoquant.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+export TORCHAO_AUTOTUNER_ENABLE=1
+
+python benchmark_pixart.py --compile --quantization=autoquant
+python benchmark_pixart.py --compile --quantization=autoquant --batch_size=4
+python benchmark_pixart.py --compile --quantization=autoquant --batch_size=8

vae-compilation/launch_fp8.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+python benchmark_pixart.py --compile --quantization=fp8
+python benchmark_pixart.py --compile --quantization=fp8 --batch_size=4
+python benchmark_pixart.py --compile --quantization=fp8 --batch_size=8

vae-compilation/launch_profile.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+export TORCH_LOGS='output_code,graph_breaks,recompiles'
+
+TORCH_LOGS_OUT=regular.txt python3 profile_pixart.py --compile 2>&1 | grep "Output code written to: " | awk -F" " '{print $NF}'
+TORCH_LOGS_OUT=int8wo.txt python3 profile_pixart.py --compile --quantization=int8wo 2>&1 | grep "Output code written to: " | awk -F" " '{print $NF}'
+TORCH_LOGS_OUT=int8dyn.txt python3 profile_pixart.py --compile --quantization=int8dyn 2>&1 | grep "Output code written to: " | awk -F" " '{print $NF}'
+TORCH_LOGS_OUT=int4wo.txt python3 profile_pixart.py --compile --quantization=int4wo 2>&1 | grep "Output code written to: " | awk -F" " '{print $NF}'

vae-compilation/profile_pixart.py

@@ -0,0 +1,137 @@
+import torch
+
+torch.set_float32_matmul_precision("high")
+
+from torch._inductor import config as inductorconfig
+
+inductorconfig.triton.unique_kernel_names = True
+
+import functools
+from diffusers import DiffusionPipeline
+import gc
+
+from torchao.quantization import (
+    int4_weight_only,
+    int8_weight_only,
+    int8_dynamic_activation_int8_weight,
+    quantize_,
+    autoquant,
+)
+from torchao.prototype.quant_llm import fp6_llm_weight_only
+from torchao.sparsity import sparsify_, int8_dynamic_activation_int8_semi_sparse_weight
+import argparse
+
+
+PROMPT = "Eiffel Tower was Made up of more than 2 million translucent straws to look like a cloud, with the bell tower at the top of the building, Michel installed huge foam-making machines in the forest to blow huge amounts of unpredictable wet clouds in the building's classic architecture."
+PREFIXES = {
+    "stabilityai/stable-diffusion-3-medium-diffusers": "sd3",
+    "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS": "pixart",
+    "fal/AuraFlow": "auraflow",
+}
+
+
+def flush():
+    gc.collect()
+    torch.cuda.empty_cache()
+    torch.cuda.reset_max_memory_allocated()
+    torch.cuda.reset_peak_memory_stats()
+
+
+def profiler_runner(path, fn, *args, **kwargs):
+    with torch.profiler.profile(
+        activities=[torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA], record_shapes=True
+    ) as prof:
+        result = fn(*args, **kwargs)
+    prof.export_chrome_trace(path)
+    return result
+
+
+def load_pipeline(
+    ckpt_id: str,
+    fuse_attn_projections: bool,
+    compile: bool,
+    quantization: str,
+    sparsify: bool,
+) -> DiffusionPipeline:
+    pipeline = DiffusionPipeline.from_pretrained(ckpt_id, torch_dtype=torch.bfloat16).to("cuda")
+
+    if fuse_attn_projections:
+        pipeline.transformer.fuse_qkv_projections()
+
+    if quantization == "autoquant" and compile:
+        pipeline.transformer.to(memory_format=torch.channels_last)
+        pipeline.transformer = torch.compile(pipeline.transformer, mode="max-autotune", fullgraph=True)
+
+    if not sparsify:
+        if quantization == "int8dq":
+            quantize_(pipeline.transformer, int8_dynamic_activation_int8_weight())
+        elif quantization == "int8wo":
+            quantize_(pipeline.transformer, int8_weight_only())
+        elif quantization == "int4wo":
+            quantize_(pipeline.transformer, int4_weight_only())
+        elif quantization == "fp6":
+            quantize_(pipeline.transformer, fp6_llm_weight_only())
+        elif quantization == "autoquant":
+            pipeline.transformer = autoquant(pipeline.transformer)
+
+    if sparsify:
+        sparsify_(pipeline.transformer, int8_dynamic_activation_int8_semi_sparse_weight())
+
+    if quantization != "autoquant" and compile:
+        pipeline.transformer.to(memory_format=torch.channels_last)
+        pipeline.transformer = torch.compile(pipeline.transformer, mode="max-autotune", fullgraph=True)
+
+    pipeline.set_progress_bar_config(disable=True)
+    return pipeline
+
+
+def run_inference(pipe, batch_size):
+    _ = pipe(
+        prompt=PROMPT,
+        num_images_per_prompt=batch_size,
+        generator=torch.manual_seed(2024),
+    )
+
+
+def run_profile(pipeline, args):
+    for _ in range(5):
+        run_inference(pipeline, batch_size=args.batch_size)
+
+    ckpt_id = PREFIXES[args.ckpt_id]
+    prefix = f"ckpt@{ckpt_id}-bs@{args.batch_size}-fuse@{args.fuse_attn_projections}-compile@{args.compile}-quant@{args.quantization}-sparsify@{args.sparsify}"
+    trace_path = f"{prefix}_trace.json"
+
+    runner = functools.partial(profiler_runner, trace_path)
+    with torch.autograd.profiler.record_function("diffusers-torchao"):
+        runner(run_inference, pipeline, args.batch_size)
+
+    return trace_path
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--ckpt_id", default="PixArt-alpha/PixArt-Sigma-XL-2-1024-MS", type=str)
+    parser.add_argument("--fuse_attn_projections", action="store_true")
+    parser.add_argument("--compile", action="store_true")
+    parser.add_argument(
+        "--quantization",
+        default="None",
+        choices=["int8dq", "int8wo", "int4wo", "autoquant", "fp6", "None"],
+        help="Which quantization technique to apply",
+    )
+    parser.add_argument("--sparsify", action="store_true")
+    parser.add_argument("--batch_size", default=1, type=int, choices=[1, 4, 8])
+    args = parser.parse_args()
+
+    flush()
+
+    pipeline = load_pipeline(
+        ckpt_id=args.ckpt_id,
+        fuse_attn_projections=args.fuse_attn_projections,
+        compile=args.compile,
+        quantization=args.quantization,
+        sparsify=args.sparsify,
+    )
+
+    trace_path = run_profile(pipeline, args)
+    print(f"Trace path generated at: {trace_path}")