How much to stage listing photos: TensorRT 10.3 FP8 vs FP16 — $39 per 1,000 on AWS p5.48xlarge in 2026

This guide delivers a verify-before-you-commit cost comparison of TensorRT 10.3 FP8 versus FP16 for Stable Diffusion XL inpainting of 1024×1024 virtually staged listing photos on an AWS p5.48xlarge in 2026.

The actual cost per 1,000 images changes with live regional pricing, selected purchase tier, and measured throughput and utilization across the instance’s 8x NVIDIA H100 GPUs.

How It Works

TensorRT turns a Stable Diffusion XL inpainting pipeline into a compiled, hardware-specific inference engine. The practical question is not only whether FP8 is faster, but whether the compiled FP8 engine preserves listing-photo quality while reducing instance-hours on a p5.48xlarge. Cost per 1,000 images is therefore a measurement problem: build the engine, run a fixed set of masked 1024×1024 photos, record verified images per instance-hour, then multiply by the live hourly rate.

FP16 uses 16 bits per value and is the familiar baseline for diffusion inference. FP8 uses 8 bits per value, which can reduce weight and activation memory and increase throughput on NVIDIA H100 GPUs when TensorRT routes supported operations to FP8 tensor cores. The trade-off is that FP8 needs calibration to set scale factors, and unsupported or numerically sensitive operations may remain in FP16. In practice, an FP8 engine is often mixed-precision rather than uniformly 8-bit.

For inpainting, the engine must handle the prompt, the mask, and the masked image together through the text encoders, UNet denoising loop, and VAE decode. TensorRT may split this into multiple engines, and variable mask sizes can require dynamic shapes. Batch size, warm-up, and host-to-device transfer all affect measured throughput, so a text-to-image benchmark is not a valid substitute for an inpainting benchmark.

The cost formula is straightforward: 1,000 divided by verified accepted images per instance-hour, multiplied by the live p5.48xlarge hourly rate. Use the starting rate and instance details already listed in the takeaways above as a check, and verify region, term, and availability before committing.

Before committing, verify the complete option: build both FP16 and FP8 engines, run identical seeds, prompts, masks, and batch sizes, inspect edge artifacts and texture consistency, and compare measured throughput. If FP8 changes visible quality on staged interiors, the cheaper per-image rate is not actually cheaper.

Key Factors to Consider

The decision should rest on verified, complete results rather than a precision label. For this workload, the top three criteria are engine completeness, like-for-like total cost, and accepted-image quality. A candidate is comparable only when the same graph, inputs, masks, batch size, and output requirements are used for both FP8 and FP16.

First, verify engine completeness before trusting any speedup. Check the TensorRT build report for unsupported operators, precision fallbacks, and whether the VAE, text encoder, or inpainting mask channels changed precision or were left out of the compiled engine. If FP8 silently falls back to FP16 in key layers, the measured gain is not an FP8 gain and the two options are not comparable.

Second, compare total cost on identical terms. Cost per 1,000 accepted images should include instance hours for the full run, storage, and any transfer or queueing overhead, not just per-image latency. Use the live p5.48xlarge rate and your measured throughput, as priced above, rather than assuming either precision's speed. Divide total accepted-image cost by 1,000 only after both runs use the same acceptance rule.

Third, set a quality gate on held-out listing photos. Score seam visibility, texture repetition, color shift, edge blending, and hallucinated objects with the same rubric and reviewer set for both engines. Track acceptance rate and rework rate; an FP8 engine that is faster but increases rejected or manually corrected images can raise the true cost per accepted image.

To make the comparison real, run both engines on the same prompt set, masks, seeds, scheduler settings, batch size, and post-processing path, then count only images that pass your listing-photo review. Apply the cost formula above to each engine's accepted-images-per-hour figure and the verified hourly rate; compare the two totals. This keeps the result tied to delivered work rather than raw kernel speed, and it prevents a faster engine with more rejects from appearing cheaper than it is.

FP16 wins when visual reliability matters more than marginal throughput. If FP8 introduces mask-edge artifacts, texture shifts, or staging inconsistencies that increase manual review or reruns, FP16 is the safer production choice even before you compare speed. In that case, the side-by-side result is clear: FP16 has the lower effective cost per 1,000 accepted photos because it avoids rework.

FP8 wins when it passes the same quality gate and your benchmark shows a lower accepted cost per 1,000 on the verified p5.48xlarge rate. The practical winner is therefore conditional, not automatic: choose FP8 only after a matched run proves both acceptance and cost advantages; otherwise, keep FP16 as the default for virtually staged listing photos.

What to do next

Frequently Asked Questions

Does the grounded p5.48xlarge spec include storage beyond GPUs, vCPUs, and RAM?

The grounded specs include 8 SSD drives alongside the GPUs, vCPUs, and RAM according to CloudPricer/CloudPrice.

What pricing details must be confirmed before committing to a cost-per-1,000 estimate?

CloudPricer lists a starting price and monthly figure, but you must confirm current region, tier, and total terms.

How should TensorRT 10.3 FP8 and FP16 be compared for this workload?

They should be compared on a like-for-like SDXL inpainting workload using the same model, resolution, batch/settings, and instance configuration.

What determines the final cost per 1,000 virtually staged photos?

Measured throughput per H100 and end-to-end utilization determine the final cost per 1,000 virtually staged photos.

What should be validated before committing to the estimate?

You should validate images per second, GPU count used, preprocessing and postprocessing time, and complete runtime costs before committing.

Why might the actual cost per 1,000 images differ from the estimate?

The actual cost per 1,000 images changes with live regional pricing, selected purchase tier, and measured throughput and utilization across the instance’s 8x NVIDIA H100 GPUs.

Quick answers

Also worth reading: Cut image generation costs: 2026 Batch 16 vs 32 Stable Diffusion XL Half Precision (FP16): Cut image generation costs: 2026 · Image generation speed test 2026: Stable Diffusion XL 8 vs 32 cap, 32 cost wins: Image generation speed test 2026: · TensorRT Fixed-Shape Graph Boosts Diffusion Batch 2.5x on A100: TensorRT Fixed-Shape Graph Boosts Diffusion