Topaz Labs Proteus 4

Introduction

Every repair Proteus makes is a numbered weight, and settings.enhancement.mode decides who sets them. Left to itself the model measures the clip and fills in all ten. Name a weight yourself and you either shift the measurement or replace it, depending on the mode you asked for.

This is what separates Proteus from an upscaler with a single quality dial. The same footage can be treated four different ways without regenerating anything, which matters when a house look has to repeat across a library rather than land once.

The four takes above are one source clip and one model. Only settings.enhancement changed between them.

The three modes

auto is the default and the whole request when the footage is ordinary. The model reads the clip and applies the weights it estimates from it. It accepts no weights at all, so the moment you want to influence one you have to leave auto behind.

relative keeps the estimates and adds your value on top, which is why its numbers stay small. A compression of 0.4 in relative mode means "whatever you measured, plus a bit more". manual ignores that negotiation and uses your value as sent, and any weight you leave out keeps the model's own value. Relative adapts to each clip, manual repeats itself exactly.

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/4d5e6f70-8192-4a3b-c4d5-e6f708192a3b.mp4'
  },
  settings: {
    enhancement: {
      mode: 'relative',
      compression: 0.6
    }
  }
})

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/4d5e6f70-8192-4a3b-c4d5-e6f708192a3b.mp4"
            },
            "settings": {
                "enhancement": {
                    "mode": "relative",
                    "compression": 0.6
                }
            }
        })


asyncio.run(main())

curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "upscale",
      "taskUUID": "e6f7a8b9-0c1d-4e2f-a3b4-c5d6e7f8a9b0",
      "model": "topazlabs:proteus@4",
      "deliveryMethod": "async",
      "width": 1920,
      "height": 1080,
      "inputs": {
        "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/4d5e6f70-8192-4a3b-c4d5-e6f708192a3b.mp4"
      },
      "settings": {
        "enhancement": {
          "mode": "relative",
          "compression": 0.6
        }
      }
    }
  ]'

runware run topazlabs:proteus@4 \
  deliveryMethod=async \
  width=1920 \
  height=1080 \
  inputs.video=https://vm.runware.ai/video/os/a14d18/ws/2/vi/4d5e6f70-8192-4a3b-c4d5-e6f708192a3b.mp4 \
  settings.enhancement.mode=relative \
  settings.enhancement.compression=0.6

{
  "taskType": "upscale",
  "taskUUID": "e6f7a8b9-0c1d-4e2f-a3b4-c5d6e7f8a9b0",
  "model": "topazlabs:proteus@4",
  "deliveryMethod": "async",
  "width": 1920,
  "height": 1080,
  "inputs": {
    "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/4d5e6f70-8192-4a3b-c4d5-e6f708192a3b.mp4"
  },
  "settings": {
    "enhancement": {
      "mode": "relative",
      "compression": 0.6
    }
  }
}

[
  {
    "taskType": "upscale",
    "taskUUID": "e6f7a8b9-0c1d-4e2f-a3b4-c5d6e7f8a9b0",
    "videoUUID": "1b2c3d4e-5f60-4718-9a2b-3c4d5e6f7081",
    "videoURL": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/1b2c3d4e-5f60-4718-9a2b-3c4d5e6f7081.mp4"
  }
]

Each weight runs from −1 to 1, where 0 leaves that repair where the model put it, positive asks for more of it, and negative pulls it back below the estimate.

The weights are meant to travel together. One request carries the whole set, the way the manual take in the hero does, and the repairs interact: clearing compression changes what the noise weight sees, and reducing noise changes what detail reconstruction has left to work with. The sections below take them one at a time so you can see what each contributes on its own, which is a way to learn them rather than a way to use them.

Reverting compression

compression targets the blocking and banding a low-bitrate encode leaves behind, the square patches in flat areas and the stepped gradients in a sky. It is the first weight to reach for on anything that arrived through a web upload or a messaging app, because that damage sits on top of the picture rather than inside it.

Auto removes the blocking on its own, and it is worth being clear about the third take: compression +0.6 is close to indistinguishable from it. The estimate was already in the right place, and a nudge above a good estimate is not where this weight pays off. Motion-heavy footage like this starves the encoder first, so the damage is real, but auto reads that damage correctly without being told.

Reducing noise

noise controls how hard the model suppresses sensor noise and grain before it rebuilds detail. Low-light footage is where it earns its keep, and also where it does the most damage, because the model cannot tell noise from the fine texture sitting underneath it.

The shadows go cleaner with the weight raised, and the linen loses some of its weave along with the grain. That trade is the reason prenoise exists, covered in grain and texture. Raise noise for shadow-heavy footage and keep it low whenever fabric or skin carries the shot.

Recovering detail

details sets how much fine structure the model reconstructs as it scales. It is the weight people reach for first and regret fastest, because detail reconstruction amplifies whatever else is in the frame, noise included.

The twill weave and the topstitching arrive with the weight raised, which is exactly what a fashion listing needs and exactly what a noisy interior shot cannot afford. Raise details on clean sources and clear the noise first on dirty ones, in that order.

Clearing halos

halo removes the bright and dark fringes that ring high-contrast edges. They are rarely in the original footage. They get baked in by an earlier sharpening pass or a broadcast encode, and they get worse when a model sharpens on top of them.

A halo is one or two pixels wide, so it vanishes at page width and the swapper above cannot show it to you. At 100% it is unmistakable:

The pale line running along both sides of every dark beam in the left crop is the halo. It traces the shape of the edge, which is what separates it from a reflection or a flare, and it sits on the bright side of a dark-to-light transition. On the right the beams meet the sky cleanly.

Auto cleared it here without being asked, and the halo +0.8 take in the swapper is barely distinguishable from the auto one. That is the honest shape of these weights: pushing past an estimate that was already right buys very little. The weight earns its keep when a fringe survives the default pass, which is likeliest on footage that has been sharpened more than once, and when you want to pull the correction back on a clip where auto softened an edge you wanted kept.

Relative or manual

Relative is the mode for one clip at a time. The estimates track whatever you feed it, so the same +0.4 lands differently on a clean camera original and on a battered download, which is what you want when each source is its own problem.

Manual is the mode for a batch that has to match. Identical numbers on every clip produce the same treatment regardless of what each one measures, which is how a library of episodes or a season of product videos ends up looking like one library rather than fifty decisions. The cost is that a clip whose damage differs from the rest gets the batch's treatment instead of its own.

A practical order: run a representative clip in auto, look at what it needs more or less of, tune it in relative until it lands, then move those numbers into manual for the rest of the batch.

Tips

1. Set the mode in the same object as the weights. mode lives at settings.enhancement.mode, alongside the weights it governs, and a weight without relative or manual fails validation.

2. Isolate while you diagnose, combine when you ship. Move one weight per run while you are working out what a clip needs, since the repairs interact and a single change is the only way to attribute a result. The request you settle on carries the whole set at once.

3. Keep relative values small. They stack on top of an estimate that is already in the right area, so 0.2 to 0.5 is a nudge and 1.0 is usually an overcorrection.

4. Clean before you sharpen. Compression and noise come first, detail after. Raising details on a dirty source multiplies the dirt.

5. Negative values are a tool. A weight below 0 pulls a repair back under the estimate, which is the fix when auto reads film grain as noise or sharpens a soft-by-design shot.

6. Move to manual for batches. Tune on one representative clip, then send the same numbers to every clip in the set so the results match each other rather than their individual sources.