Kostenloses KI-Upscaling auf einem GPU-Server: Upscayl, Real-ESRGAN und Video2X im Test

KI-Upscaling macht aus einem kleinen oder unscharfen Bild ein größeres und schärferes: Das Modell zieht die Pixel nicht nur auseinander, es zeichnet feine Details wie Haare, Fell oder die Kanten einer Zeichnung neu. Bezahlte Tools wie Topaz machen das gut, Online-Upscaler machen es mit Upload-Grenzen, Warteschlangen oder Wasserzeichen. Die kostenlosen Open-Source-Tools sind genauso leicht zu finden: Upscayl (eine Desktop-App auf Basis von Real-ESRGAN) und Video2X für Videos, das auch Frame-Interpolation mit RIFE und Anime4K-Filter kann.

Alle laufen über Vulkan, sie wollen also eine GPU. Daher unsere Frage: Was bringt die GPU auf einem Cloud-Server mit einer geteilten Intel-GPU wirklich, verglichen mit der CPU desselben Servers? Wir haben die offiziellen Binärdateien, dieselben Bilder und dasselbe Video verwendet und Zeit, CPU und Speicher gemessen.

Drei Ausschnitte desselben Auges: ein 512-Pixel-Foto, 4-fach bikubisch vergrößert, dasselbe Foto mit Real-ESRGAN auf der GPU vergrößert, und das hochauflösende Originalfoto — Ein Foto mit 512 × 512 Pixeln, 4-fach vergrößert. Links: klassische bikubische Skalierung. Mitte: Real-ESRGAN (Modell x4plus) auf der Intel-GPU, 25 Sekunden. Rechts: das hochauflösende Originalfoto zum Vergleich. Foto: Orren Jack Turner, 1947, gemeinfrei (Wikimedia Commons).

Die Ergebnisse im Überblick

Bilder: Die GPU ist schneller und lässt die CPU frei. Ein 512-Pixel-Foto 4-fach zu vergrößern dauerte 24,9 s auf der GPU gegenüber 34,0 s auf 4 vCPU (1,4-mal schneller) und 55 s auf 2 vCPU (2,2-mal schneller). Der GPU-Durchlauf brauchte 0,1 vCPU; der CPU-Durchlauf belegte 3,8 vCPU.
Große Bilder brauchen auf der CPU viel Speicher. Ein 1080p-Foto auf 8K vergrößert dauerte 189 s auf der GPU und 234 s auf der CPU, und der CPU-Durchlauf erreichte in der Spitze 11,8 GB RAM (1,2 GB mit der GPU).
Video2X hat keinen CPU-Modus. Über Software-Vulkan auf die CPU gezwungen, war es 4- bis 6-mal langsamer: Anime4K auf 1080p lief mit 12,2 Bildern pro Sekunde auf der GPU gegenüber 1,9, die Bildverdopplung mit RIFE mit 7,3 gegenüber 1,1.
Real-ESRGAN ist bei Videos langsam, auch auf der GPU. Das schnelle Videomodell schaffte 0,65 Bilder pro Sekunde: etwa 8 Minuten für einen 10-Sekunden-Clip. Gut für einen kurzen Clip oder einen Stapel über Nacht, nicht für einen Film.
Ehrlich zur Hardware. Eine integrierte GPU ist viel langsamer als eine Desktop-RTX-Karte. Der Punkt ist ein Server für 14,99 €, der die Arbeit erledigt, ohne seine CPU zu belegen.

Testaufbau

Element	Wert
Server	Debian 13, Linux 7.3, Intel UHD 770 (geteilte GPU), 4 vCPU, 12 GB RAM
Bilder, GPU	upscayl-bin 20251207 (die Engine, die die Upscayl-App aufruft, offizielles Release) mit den Real-ESRGAN-Modellen, Vulkan (Mesa 25.0.7), Standard-Kachelgröße
Bilder, CPU	der offizielle PyTorch-Code von Real-ESRGAN (`inference_realesrgan.py`, PyTorch 2.15 CPU, fp32, 4 Threads; 2 Threads, an 2 vCPU gebunden, für das Ergebnis „2 vCPU“)
Video	Video2X 6.4.0 (offizielles AppImage), Ausgabe H.264 (libx264, CRF 18). CPU: dasselbe Video2X auf dem Software-Vulkan von Mesa (llvmpipe), dazu das offizielle PyTorch-Videoskript für Real-ESRGAN
Bilder	drei Fotos mit 512 × 512, ein Foto mit 1920 × 1080, ein Zeichentrickbild mit 854 × 480
Video	10 s Big Buck Bunny in 854 × 480, 30 Bilder pro Sekunde (300 Bilder)
Messungen	Gesamtzeit inklusive Laden des Modells und Schreiben der Datei, CPU-Zeit und Spitzenspeicher aus `/usr/bin/time`

Die CPU-Werte sind in vCPU angegeben (1,0 = ein voller Kern). Die GPU wird mit anderen Servern geteilt: Wir haben geprüft, dass sie während der hier verwendeten Durchläufe sonst nicht genutzt wurde (siehe „Grenzen“).

Testmedien: Fotos von Wikimedia Commons (Albert Einstein von Orren Jack Turner, gemeinfrei; Buzz Aldrin von der NASA, gemeinfrei; eine Katze von Alvesgaspar, CC BY-SA 3.0) und Big Buck Bunny (© Blender Foundation, CC BY 3.0).

1. Bilder: Real-ESRGAN mit der Engine von Upscayl

Sekunden pro Bild, 4-fach vergrößert, inklusive Laden des Modells. Grün: die Intel-GPU mit upscayl-bin. Orange: der offizielle PyTorch-Code auf den 4 vCPU desselben Servers.

Bild	Modell	GPU	CPU, 4 vCPU	CPU, 2 vCPU
Foto 512 × 512 → 2048 × 2048	RealESRGAN x4plus	24,9 s, 0,1 vCPU, 1,0 GB	34,0 s, 3,8 vCPU, 4,1 GB	55,0 s
Foto 1920 × 1080 → 7680 × 4320	RealESRGAN x4plus	189 s, 0,03 vCPU, 1,2 GB	234 s, 4,0 vCPU, 11,8 GB	—
Zeichentrickbild 854 × 480 → 3416 × 1920	x4plus-anime	12,9 s, 0,1 vCPU, 0,4 GB	17,9 s, 3,6 vCPU, 6,0 GB	—
Videobild 854 × 480 → 3416 × 1920	animevideov3 (schnell)	2,2 s, 0,6 vCPU	4,0 s, 2,4 vCPU, 0,9 GB	—

Die Zeit für das Foto ist der Median von drei verschiedenen Fotos; alle brauchten auf der GPU zwischen 24,8 und 25 Sekunden.

Was das bedeutet:

Gegenüber allen 4 vCPU ist die GPU 1,2- bis 1,8-mal schneller. Das ist ein echter Gewinn, kein Wunder: Das Fotomodell von Real-ESRGAN ist schwer, und vier moderne CPU-Kerne sind nicht langsam.
Gegenüber 2 vCPU, der Größe unseres Start-Angebots, ist die GPU 2,2-mal schneller. Die GPU schrumpft nicht mit dem Angebot; die CPU schon.
Die GPU lässt den Server frei. Während eines GPU-Durchlaufs bleibt die CPU des Servers bei etwa 0,1 vCPU: Sie können gleichzeitig eine Web-App, eine Galerie oder einen zweiten Auftrag laufen lassen. Auf der CPU nimmt das Upscaling alles.
Speicher. Ohne Kacheln brauchte der PyTorch-Code 11,8 GB RAM für das 1080p-Foto. Auf einem Server mit 8 GB müssten Sie das Bild auch auf der CPU in Kacheln aufteilen, was es noch langsamer macht.

Drei Ausschnitte eines Katzengesichts: bikubische 4-fache Vergrößerung, Real-ESRGAN 4x auf der GPU und das Originalfoto — Derselbe Test mit einer Katze: bikubisch (links), Real-ESRGAN x4plus auf der GPU (Mitte), Originalfoto (rechts). Real-ESRGAN bringt scharfes Fell und scharfe Schnurrhaare zurück; es erfindet aber auch Details, vergleichen Sie also mit dem Original, wenn es auf Genauigkeit ankommt. Foto: Alvesgaspar, Wikimedia Commons, CC BY-SA 3.0.

Zwei Ausschnitte eines Zeichentrick-Eichhörnchens: links bikubische 4-fache Vergrößerung, rechts Real-ESRGAN animevideov3 auf der GPU mit schärferen Umrissen — Ein 480p-Zeichentrickbild, 4-fach vergrößert: bikubisch (links) und das schnelle Videomodell von Real-ESRGAN auf der GPU (rechts, 2,2 s). Saubere Linien, flächige Farben. Big Buck Bunny, © Blender Foundation, CC BY 3.0.

2. Video: Video2X mit Real-ESRGAN, Anime4K und RIFE

Video2X liest ein Video, schickt jedes Bild auf der GPU durch einen Filter und kodiert das Ergebnis mit FFmpeg. Es bietet drei Arten von Arbeit: Real-ESRGAN (KI-Upscaling, langsam, beste Qualität), Anime4K (schnelle GLSL-Shader für Zeichentrick, über libplacebo) und RIFE (KI-Frame-Interpolation: von 30 auf 60 Bilder pro Sekunde).

Balkendiagramm: Bilder pro Sekunde von Video2X auf der GPU und auf der CPU für Real-ESRGAN x4, Anime4K auf 1080p und die Bildverdopplung mit RIFE — Von Video2X 6.4 pro Sekunde verarbeitete Quellbilder. Grün: Intel-GPU. Orange: dasselbe Video2X, auf die CPU gezwungen (Software-Vulkan von Mesa), mit den 4 vCPU.

Video2X-Auftrag (Quelle 854 × 480)	GPU	CPU (Software-Vulkan)	10-Sekunden-Clip auf der GPU
Real-ESRGAN animevideov3 ×4 → 3416 × 1920	0,65 fps, 0,1 vCPU	0,15 fps, 3,8 vCPU	etwa 7 min 40 s
Real-ESRGAN animevideov3 ×2 → 1708 × 960	0,65 fps	—	etwa 7 min 40 s
Anime4K → 1920 × 1080	12,2 fps, 0,7 vCPU	1,9 fps, 3,1 vCPU	25 s
Anime4K → 3840 × 2160	7,4 fps, 1,5 vCPU	—	40 s
RIFE v4.6, 30 → 60 fps	7,3 fps (14,6 ausgegebene Bilder pro Sekunde), 0,2 vCPU	1,1 fps, 3,1 vCPU	41 s
Real-ESRGAN x4plus (Fotomodell) ×4	0,02 fps (48 s pro Bild)	—	etwa 4 Stunden

Um Real-ESRGAN mit einem Tool zu vergleichen, das wirklich für die CPU optimiert ist, haben wir auch das offizielle PyTorch-Videoskript auf den 4 vCPU laufen lassen: 0,60 Bilder pro Sekunde, fast so schnell wie die GPU, aber mit dem ganzen Server ausgelastet (3,8 vCPU). Für Anime4K und RIFE gibt es kein solches CPU-Tool: Ohne GPU weicht Video2X auf Software-Vulkan aus und ist 6-mal langsamer.

Fünf Sekunden Big Buck Bunny in 480p, 2-fach vergrößert. Links: bikubisch. Rechts: Real-ESRGAN (animevideov3) mit Video2X auf der GPU: schärferes Gras und schärfere Blätter. Big Buck Bunny, © Blender Foundation, CC BY 3.0.

Praktische Tipps aus diesen Zahlen:

Für Zeichentrick und Anime fangen Sie mit Anime4K an: in 1080p fast in Echtzeit, und das Ergebnis ist sauber.
Nutzen Sie für Videos das Modell animevideov3 von Real-ESRGAN, nie das Fotomodell (x4plus): Mit 48 Sekunden pro Bild wird ein 10-Sekunden-Clip zu einem Vier-Stunden-Auftrag.
RIFE ist günstig: 41 Sekunden, um einen 10-Sekunden-Clip in 480p von 30 auf 60 Bilder pro Sekunde zu bringen.
Lange Videos sind ein Auftrag für die Nacht. Bei 0,65 Bildern pro Sekunde dauert eine Folge von 20 Minuten mit 30 Bildern pro Sekunde mit Real-ESRGAN etwa 15 Stunden. Der Server erledigt das, während Sie schlafen; dafür ist er da.

3. Grenzen

Geteilte GPU. Die GPU wird mit anderen Servern geteilt. Wenn ein anderer Server sie nutzt, bekommen Ihre Aufträge einen fairen Anteil, laufen aber langsamer: Während unserer Sitzung dauerte dasselbe 1080p-Foto 189 s, wenn die GPU sonst frei war, und 226 bis 268 s, während ein anderer Server sie belegte. Die Zahlen oben gelten für eine sonst freie GPU.
Behalten Sie die Standard-Kachelgröße. Mit -t 512 dauerte jeder GPU-Auftrag länger, als der Treiber erlaubt, und wurde abgebrochen: Die ausgegebenen Bilder waren schwarz. Die Standardeinstellung (automatisch) oder -t 256 funktionieren und sind genauso schnell.
Kein Wunder. Eine Desktop-RTX-Karte führt Real-ESRGAN um ein Vielfaches schneller aus. Wenn Sie jeden Tag Tausende 4K-Bilder hochskalieren, mieten Sie eine dedizierte GPU. Wenn Sie eine Fotosammlung, alte Scans oder kurze Clips hochskalieren, reicht das hier.
Die KI erfindet Details. Real-ESRGAN lässt Bilder scharf aussehen, aber die neuen Details sind geschätzt. Für Dokumente, Gesichter, die erkannt werden müssen, oder Beweismittel behalten Sie das Original.
Die Upscayl-App selbst ist ein Desktop-Programm. Auf einem Server nutzen Sie ihre Engine upscayl-bin auf der Kommandozeile (siehe unten), so wie Upscayl es hinter seinen Schaltflächen tut.

4. Welches Angebot?

iGPU Start (2 vCPU, 8 GB RAM, Perf 1, 14,99 € netto pro Monat): Fotos mit der Engine von Upscayl hochskalieren, Bildstapel, Anime4K und RIFE für kurze Videos. Hier ist die GPU 2,2-mal schneller als die 2 vCPU des Angebots und hält sie frei.
iGPU Power (4 vCPU, 14 GB RAM, Perf 2 = doppelter GPU-Anteil von Start, 29,99 €): Video2X-Aufträge, die stundenlang laufen, große Bilder (von 1080p auf 8K) oder Upscaling neben anderen Diensten. Der größere GPU-Anteil zählt, wenn andere Server die GPU gleichzeitig nutzen.
iGPU Pro (6 vCPU, 14 GB, Perf 3, 44,99 €): mehrere lange Videoaufträge hintereinander, oder Upscaling plus andere GPU-Arbeit (Transkodierung, KI-Inferenz) auf demselben Server.

5. Einrichtung auf einem Linux-GPU-Server

Lieber sofort einsatzbereit? Fragen Sie bei der Bestellung per E-Mail danach (contact@linuxgpu.eu): Wir können Ihnen den Server mit upscayl-bin, den Real-ESRGAN-Modellen und Video2X liefern, bereits installiert und auf der GPU getestet.

Unsere Server werden mit installiertem Intel-Vulkan-Treiber ausgeliefert; vulkaninfo --summary sollte die Intel UHD Graphics 770 anzeigen. Dann für Bilder:

# Die Engine von Upscayl und die Real-ESRGAN-Modelle (offizielle Releases)
wget https://github.com/upscayl/upscayl-ncnn/releases/download/20251207-174704/upscayl-bin-20251207-174704-linux.zip
wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesrgan-ncnn-vulkan-20220424-ubuntu.zip
unzip upscayl-bin-*-linux.zip && unzip -d realesrgan realesrgan-ncnn-vulkan-*-ubuntu.zip
U=./upscayl-bin-20251207-174704-linux/upscayl-bin

# ein Foto, 4-mal größer, auf der GPU (-g 0)
$U -i photo.jpg -o photo-x4.png -m realesrgan/models -n realesrgan-x4plus -g 0
# ein ganzer Ordner, Zeichentrickmodell, JPEG-Ausgabe
$U -i scans/ -o scans-x4/ -m realesrgan/models -n realesrgan-x4plus-anime -g 0 -f jpg

Für Videos gibt es Video2X 6.4 als AppImage. Server haben meist kein FUSE, also entpacken Sie es einmal:

wget https://github.com/k4yt3x/video2x/releases/download/6.4.0/Video2X-x86_64.AppImage
chmod +x Video2X-x86_64.AppImage && ./Video2X-x86_64.AppImage --appimage-extract
cd squashfs-root/usr/share/video2x       # Video2X sucht seine Modelle von hier aus
V=../../../AppRun
$V -l                                     # Gerät 0 sollte die Intel UHD 770 sein

# Real-ESRGAN, 2-mal größer
$V -i ~/clip.mp4 -o ~/clip-x2.mp4 -p realesrgan --realesrgan-model realesr-animevideov3 -s 2 -c libx264 -e crf=18
# Anime4K auf 1080p
$V -i ~/clip.mp4 -o ~/clip-1080p.mp4 -p libplacebo --libplacebo-shader anime4k-v4-a -w 1920 -h 1080
# RIFE: von 30 auf 60 Bilder pro Sekunde
$V -i ~/clip.mp4 -o ~/clip-60fps.mp4 -p rife --rife-model rife-v4.6 -m 2

Starten Sie lange Aufträge in tmux oder mit nohup, damit sie nach dem Abmelden weiterlaufen.

Zur Video-Engine derselben GPU (Dekodieren und Kodieren mit VA-API) lesen Sie Beschleunigte Videotranskodierung: keine GPU für 500 €/Monat nötig und Intel Quick Sync (VAAPI) auf einem Linux-VPS: ffmpeg-Befehle, die funktionieren. Für andere KI-Modelle auf derselben GPU siehe Günstige KI-Inferenz: OpenVINO auf integrierter GPU, ohne GPU für 500 €/Monat.

Ausprobieren

Zu den Angeboten: iGPU Start kostet 14,99 € und iGPU Power 29,99 € netto pro Monat.