Topaz Labs Proteus 4

Introduction

A clip can be measurably cleaner and still look wrong. Noise reduction takes the grain out of skin along with the noise, detail reconstruction replaces a real surface with a plausible one, and what arrives is the waxy look that reads as processed long before a viewer could say why.

Proteus carries three controls for that, and they act at three different points in the pipeline. prenoise adds noise before the enhancement runs, recoverOriginalDetail blends the source back into the result, and grain with grainSize lays a controlled grain over the finished frames after everything else.

The showroom pan is enhanced with all three in play. The leather keeps its grain and the throw keeps its weave, so the result reads as a better capture of the same sofa rather than a render of one.

Adding noise before the pass

prenoise puts a small amount of noise into the input, which sounds backwards until you look at what noise reduction does to a clean-but-soft frame. With nothing to work on, the noise weight covered in tuning the enhancement weights flattens the fine variation that skin and fabric are made of. A little noise on the way in gives it something to remove other than the texture.

Skin is where this gets judged, and it has to be judged at 100%, because a cheek at page width looks smooth either way:

The two are close, and the prenoise take is the smoother of the pair rather than the more textured one. On this clip auto's noise reduction was already restrained, so there was no over-smoothing for the added input noise to fight, and that noise left with the rest of it.

That is the shape of the control. prenoise is a counterweight to aggressive denoising, not a texture generator, so it only pays off where the denoiser is taking texture along with the noise. When a face comes back waxy, pull the noise weight down first, since that is the repair doing the smoothing, and reach for prenoise when you need the denoiser's strength on the rest of the frame but not its cost on skin.

prenoise also tops out at 0.1, which is a narrower range than the repair weights, so the 0.06 above is already past its middle.

Blending the source back in

recoverOriginalDetail mixes the original picture back into the enhanced one, from 0 to 1. It is the answer to a different failure from prenoise: not smoothing, but invention. When detail reconstruction runs hard, the surface it builds is plausible rather than accurate, and a product that has to match a real object cannot afford plausible.

The scoring on the loaves is the tell. Auto gives every crust a similar treatment, and the recovered take keeps the blistering each loaf actually had. Raise it whenever the footage is evidence, such as a product listing or a property walkthrough, where a customer compares the clip against the real thing.

The trade is sharpness. The source is the softer of the two inputs being blended, so a high value pulls some of that softness back with the accuracy.

Grain on the way out

grain and grainSize are a finishing pass, not a repair. Grain gets added after the enhancement, so it lands on the result rather than becoming something the model tries to remove. grain sets the amount, from 0 to 0.1, and grainSize sets how large each particle is, from 0 to 5.

Same amount, different particle. The fine setting reads as film stock, and the coarse one reads as a deliberate stylistic choice that a viewer will notice. Size matters more than amount for whether grain looks like an intention or an artefact.

import { createClient } from '@runware/sdk'

const client = await createClient({ apiKey: process.env.RUNWARE_API_KEY })
await client.connect()

const [result] = await client.run({
  model: 'topazlabs:proteus@4',
  deliveryMethod: 'async',
  width: 1920,
  height: 1080,
  inputs: {
    video: 'https://vm.runware.ai/video/os/a14d18/ws/2/vi/7182a3b4-c5d6-4e7f-8091-a2b3c4d5e6f7.mp4'
  },
  settings: {
    enhancement: {
      mode: 'relative',
      prenoise: 0.04,
      recoverOriginalDetail: 0.4,
      grain: 0.02,
      grainSize: 1.5
    }
  }
})

import asyncio
import os

from runware import Runware


async def main():
    async with Runware(api_key=os.environ["RUNWARE_API_KEY"]) as client:
        results = await client.run({
            "model": "topazlabs:proteus@4",
            "deliveryMethod": "async",
            "width": 1920,
            "height": 1080,
            "inputs": {
                "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/7182a3b4-c5d6-4e7f-8091-a2b3c4d5e6f7.mp4"
            },
            "settings": {
                "enhancement": {
                    "mode": "relative",
                    "prenoise": 0.04,
                    "recoverOriginalDetail": 0.4,
                    "grain": 0.02,
                    "grainSize": 1.5
                }
            }
        })


asyncio.run(main())

curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "upscale",
      "taskUUID": "d1e2f3a4-5b6c-4d7e-8f9a-0b1c2d3e4f5a",
      "model": "topazlabs:proteus@4",
      "deliveryMethod": "async",
      "width": 1920,
      "height": 1080,
      "inputs": {
        "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/7182a3b4-c5d6-4e7f-8091-a2b3c4d5e6f7.mp4"
      },
      "settings": {
        "enhancement": {
          "mode": "relative",
          "prenoise": 0.04,
          "recoverOriginalDetail": 0.4,
          "grain": 0.02,
          "grainSize": 1.5
        }
      }
    }
  ]'

runware run topazlabs:proteus@4 \
  deliveryMethod=async \
  width=1920 \
  height=1080 \
  inputs.video=https://vm.runware.ai/video/os/a14d18/ws/2/vi/7182a3b4-c5d6-4e7f-8091-a2b3c4d5e6f7.mp4 \
  settings.enhancement.mode=relative \
  settings.enhancement.prenoise=0.04 \
  settings.enhancement.recoverOriginalDetail=0.4 \
  settings.enhancement.grain=0.02 \
  settings.enhancement.grainSize=1.5

{
  "taskType": "upscale",
  "taskUUID": "d1e2f3a4-5b6c-4d7e-8f9a-0b1c2d3e4f5a",
  "model": "topazlabs:proteus@4",
  "deliveryMethod": "async",
  "width": 1920,
  "height": 1080,
  "inputs": {
    "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/7182a3b4-c5d6-4e7f-8091-a2b3c4d5e6f7.mp4"
  },
  "settings": {
    "enhancement": {
      "mode": "relative",
      "prenoise": 0.04,
      "recoverOriginalDetail": 0.4,
      "grain": 0.02,
      "grainSize": 1.5
    }
  }
}

[
  {
    "taskType": "upscale",
    "taskUUID": "d1e2f3a4-5b6c-4d7e-8f9a-0b1c2d3e4f5a",
    "videoUUID": "2c3d4e5f-6071-4829-a3b4-c5d6e7f80912",
    "videoURL": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/2c3d4e5f-6071-4829-a3b4-c5d6e7f80912.mp4"
  }
]

That payload is the showroom pan at the top of the page. Small values across all three, which is the shape most footage wants.

Grain and the delivery encode

Grain is expensive to encode. It is high-frequency detail spread across the whole frame, so it consumes bitrate that would otherwise go to the picture, and a platform encoder that runs out of budget turns it into blocking. A clip that looked right in the master can come back from a social platform looking noisy and blocky at once.

Two habits keep it from going wrong. Add grain last, on the master you are actually delivering rather than on an intermediate that gets re-encoded. And keep the amount low for platform delivery, since a value that reads as texture on a local file can read as noise once the platform has had it.

Tips

1. Match the control to the failure. Flat, waxy surfaces call for prenoise. Detail that looks invented calls for recoverOriginalDetail. Neither is a grain problem, and grain will not fix either.

2. Keep prenoise under 0.05 for most footage. It protects texture at small values and becomes visible dither above the middle of its range.

3. Raise recoverOriginalDetail when accuracy matters. Product and property footage wants the real surface, even at some cost in sharpness.

4. Set grainSize before you chase the amount. Particle size decides whether grain reads as film or as noise, and the amount only decides how much of it there is.

5. Add grain at the end of the chain. It is a look, not a repair, so it belongs on the master you deliver rather than on a file that has another encode ahead of it.

6. Check on the target platform. Grain and social encoders fight each other, and the result that matters is the one after the platform has re-encoded it.