Image-to-Image and Denoising Strength

Denoising strength is not a blend factor between your input and the output. It picks a point on the noise schedule, noises your image to exactly that level, and runs the remainder of the trajectory from there. Two consequences follow, and the second one is the reason low-strength results often look soft.

The short answer

Strength s runs from 0 to 1. At s = 1 your input is noised to the top of the schedule, which destroys it completely and gives you plain text-to-image. At s = 0.3 it is noised to thirty per cent of the way up, which leaves the coarse structure intact and the fine detail gone. At s = 0 nothing happens.

What survives is decided by which spatial frequencies are still above the noise floor at that level, which is the same frequency argument that makes early steps structural in ordinary generation.

The mechanism, in three lines

1.  Encode the input image to a latent:      z0 = VAE.encode(image)

2.  Noise it to the level implied by s:
        t = round(s × T)
        z_t = sqrt(alpha_bar_t) · z0  +  sqrt(1 − alpha_bar_t) · eps

3.  Run the sampler from t down to 0, exactly as normal.

There is no blending step. There is no "keep 70% of the original". The
original enters as the low-frequency content of z_t and nothing else.

This is why img2img at moderate strength can change an object’s identity while keeping its position: position is low-frequency and survives the noising; surface identity is higher-frequency and does not.

Strength secretly changes your step count

Here is the part that is almost never stated. The sampler runs from t down to zero, and t is a fraction of the schedule. So the number of steps actually executed is the fraction of your nominal step count that lies below t.

actual_steps = round(nominal_steps × strength)

With nominal_steps = 30:

  strength   actual steps   NFE with guidance
  --------------------------------------------
    1.0          30               60
    0.8          24               48
    0.6          18               36
    0.5          15               30
    0.4          12               24
    0.3           9               18
    0.2           6               12
    0.1           3                6

So a low-strength pass is cheap — and under-integrated. At strength 0.2
you are running six steps, which is below where most samplers have
converged. The result is soft, and people attribute the softness to the
strength when part of it is the step count.

The fix is to raise the nominal step count so that the executed count stays where you want it:

nominal_steps = target_steps / strength

Want 20 executed steps at strength 0.35?
    nominal = 20 / 0.35 = 58

Cost check: 20 executed steps costs what 20 steps cost. Raising the
nominal number does not make the pass more expensive — it only changes
where on the schedule those 20 evaluations are placed.

That last note is the useful part. Increasing nominal steps for a low-strength pass is nearly free, because you only pay for the steps that run. It is one of the few adjustments in this stack that improves the result at no cost.

What survives at each strength

These bands are descriptions of the mechanism, not measurements. What survives at a given strength depends on the model, the schedule and the content, so treat them as a starting point and calibrate with the seed fixed.

The high-resolution pass

The most common production use of img2img is a two-stage generation: make the image at a resolution the model was trained for, upscale it conventionally, then run a low-strength img2img pass at the higher resolution to put real detail into it.

1. Generate at a native resolution — for a 1024-base model, something near one megapixel. Generating directly at 2048×2048 produces duplicated subjects for the reasons set out in aspect ratio and training buckets.
2. Upscale with a conventional or learned upscaler to the target size. Which family to use is covered in image upscaling.
3. Run img2img at strength 0.25 to 0.45 with the same prompt and the same seed. The upscaled image supplies the structure; the pass supplies detail the upscaler could not invent.

Cost of the two-stage approach, using the scaling from the compute page:

  Stage 1   1024²,  30 steps          =  30 steps at 1024² cost
  Stage 2   2048²,  30 nominal × 0.35 =  ~10 steps at 2048² cost

  From the compute page, a 2048² step costs about 7× a 1024² step, so:

      stage 1  =  30 units
      stage 2  =  10 × 7 = 70 units
      total    = 100 units

  Versus generating 30 steps directly at 2048²:  30 × 7 = 210 units.

  Roughly half the compute, and without the duplicated-subject failure.

The arithmetic behind the 7× factor is derived in the GPU-seconds page.

Strength against the other ways to keep an image

Denoising strength is one of four mechanisms for making an output resemble an input, and they are not interchangeable. Choosing the wrong one is the most common structural mistake in this part of the stack, because they all look like a “keep the original” dial in a user interface.

They compose. A production pipeline that regenerates a product photo on a new background will commonly use a mask to keep the product, a depth signal to keep its placement, and a low-strength final pass to harmonise the lighting across the seam.

Diagnosing a bad img2img result

The chained-passes point in that table is worth separating out. Each img2img pass costs one encode and one decode, and the reconstruction error of the autoencoder is not recovered between them. A workflow of six sequential refinement passes has been through the compressor six times, and the accumulated softness is frequently mistaken for the model being weak. The ceiling that sets is derived in the latent diffusion page.

What strength cannot do

• It cannot preserve a specific region. Strength acts uniformly on the whole latent. If you want part of the image untouched, that is a mask, not a strength setting. See inpainting and outpainting.
• It cannot preserve identity. A face survives low strength because its pixels survive, not because the model is tracking a person. Past roughly the middle of the range it becomes a different face. Identity across generations needs reference conditioning — see keeping a character consistent.
• It cannot add resolution. Running img2img at a larger canvas resamples your input first. The detail comes from the model, not from the source, which makes it invention rather than recovery.
• It is not comparable across schedules. Strength 0.4 maps to a noise level through the schedule, and two schedules put different noise levels at the same fraction. A value carried between pipelines will not mean the same thing.