Escalado con IA gratis en un servidor GPU: Upscayl, Real-ESRGAN y Video2X a prueba

El escalado con IA convierte una imagen pequeña o borrosa en una más grande y más nítida: el modelo no se limita a estirar los píxeles, sino que vuelve a dibujar los detalles finos como el pelo, el pelaje o los bordes de un dibujo. Las herramientas de pago como Topaz lo hacen bien, y los escaladores en línea lo hacen con límites de subida, colas o marcas de agua. Las herramientas gratuitas y de código abierto son igual de fáciles de encontrar: Upscayl (una aplicación de escritorio basada en Real-ESRGAN) y Video2X para vídeo, que también hace interpolación de fotogramas con RIFE y filtros Anime4K.

Todas funcionan con Vulkan, así que quieren una GPU. Por eso nos preguntamos: en un servidor en la nube con una GPU Intel compartida, ¿cuánto aporta de verdad la GPU frente a la CPU del mismo servidor? Usamos los binarios oficiales, las mismas imágenes y el mismo vídeo, y medimos el tiempo, la CPU y la memoria.

Resultados de un vistazo

• Imágenes: la GPU es más rápida y deja libre la CPU. Ampliar 4 veces una foto de 512 píxeles tardó 24,9 s en la GPU frente a 34,0 s en 4 vCPU (1,4 veces más rápido) y 55 s en 2 vCPU (2,2 veces más rápido). La prueba en GPU usó 0,1 vCPU; la prueba en CPU mantuvo ocupadas 3,8 vCPU.
• Las imágenes grandes necesitan memoria en la CPU. Una foto 1080p ampliada a 8K tardó 189 s en la GPU y 234 s en la CPU, y la prueba en CPU llegó a un pico de 11,8 GB de RAM (1,2 GB con la GPU).
• Video2X no tiene modo CPU. Forzado a la CPU mediante Vulkan por software, fue de 4 a 6 veces más lento: Anime4K a 1080p funcionó a 12,2 fotogramas por segundo en la GPU frente a 1,9, y la duplicación de fotogramas con RIFE a 7,3 frente a 1,1.
• Real-ESRGAN en vídeo es lento, incluso en la GPU. El modelo de vídeo rápido procesó 0,65 fotogramas por segundo: unos 8 minutos para un clip de 10 segundos. Bien para un clip corto o un lote por la noche, no para una película.
• Seamos honestos con el hardware. Una GPU integrada es mucho más lenta que una tarjeta RTX de escritorio. La idea es un servidor de 14,99 € que hace el trabajo sin tener la CPU ocupada.

Configuración de la prueba

Elemento	Valor
Servidor	Debian 13, Linux 7.3, Intel UHD 770 (GPU compartida), 4 vCPU, 12 GB de RAM
Imágenes, GPU	upscayl-bin 20251207 (el motor al que llama la aplicación Upscayl, versión oficial) con los modelos de Real-ESRGAN, Vulkan (Mesa 25.0.7), tamaño de tesela por defecto
Imágenes, CPU	el código PyTorch oficial de Real-ESRGAN (inference_realesrgan.py, PyTorch 2.15 CPU, fp32, 4 hilos; 2 hilos fijados a 2 vCPU para el resultado «2 vCPU»)
Vídeo	Video2X 6.4.0 (AppImage oficial), salida H.264 (libx264, CRF 18). CPU: el mismo Video2X sobre el Vulkan por software de Mesa (llvmpipe), más el script de vídeo PyTorch oficial para Real-ESRGAN
Imágenes	tres fotos de 512 × 512, una foto de 1920 × 1080, un fotograma de dibujos animados de 854 × 480
Vídeo	10 s de Big Buck Bunny a 854 × 480, 30 fotogramas por segundo (300 fotogramas)
Mediciones	tiempo real incluida la carga del modelo y la escritura del archivo, tiempo de CPU y pico de memoria con /usr/bin/time

Las cifras de CPU están en vCPU (1,0 = un núcleo completo). La GPU se comparte con otros servidores: comprobamos que no la usaba nadie más durante las pruebas que mostramos aquí (ver «Límites»).

Material de prueba: fotos de Wikimedia Commons (Albert Einstein por Orren Jack Turner, dominio público; Buzz Aldrin por la NASA, dominio público; un gato por Alvesgaspar, CC BY-SA 3.0) y Big Buck Bunny (© Blender Foundation, CC BY 3.0).

1. Imágenes: Real-ESRGAN con el motor de Upscayl

Imagen	Modelo	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	—
Fotograma de dibujos animados 854 × 480 → 3416 × 1920	x4plus-anime	12,9 s, 0,1 vCPU, 0,4 GB	17,9 s, 3,6 vCPU, 6,0 GB	—
Fotograma de vídeo 854 × 480 → 3416 × 1920	animevideov3 (rápido)	2,2 s, 0,6 vCPU	4,0 s, 2,4 vCPU, 0,9 GB	—

El tiempo de la foto es la mediana de tres fotos distintas; todas tardaron entre 24,8 y 25 segundos en la GPU.

Qué significa:

• Frente a las 4 vCPU, la GPU es de 1,2 a 1,8 veces más rápida. Es una mejora real, no un milagro: el modelo de fotos de Real-ESRGAN es pesado, y cuatro núcleos de CPU modernos no son lentos.
• Frente a 2 vCPU, el tamaño de nuestro plan Start, la GPU es 2,2 veces más rápida. La GPU no se reduce con el plan; la CPU sí.
• La GPU deja libre el servidor. Durante una prueba en GPU, la CPU del servidor se queda en unos 0,1 vCPU: puedes ejecutar una aplicación web, una galería o un segundo trabajo al mismo tiempo. En la CPU, el escalado se lo lleva todo.
• Memoria. Sin dividir en teselas, el código PyTorch necesitó 11,8 GB de RAM para la foto 1080p. En un servidor de 8 GB también tendrías que dividir la imagen en teselas en la CPU, lo que la hace aún más lenta.

2. Vídeo: Video2X con Real-ESRGAN, Anime4K y RIFE

Video2X lee un vídeo, pasa cada fotograma por un filtro en la GPU y codifica el resultado con FFmpeg. Ofrece tres tipos de trabajo: Real-ESRGAN (escalado con IA, lento, la mejor calidad), Anime4K (shaders GLSL rápidos para dibujos animados, mediante libplacebo) y RIFE (interpolación de fotogramas con IA: de 30 a 60 fotogramas por segundo).

Trabajo de Video2X (origen 854 × 480)	GPU	CPU (Vulkan por software)	Clip de 10 segundos en la GPU
Real-ESRGAN animevideov3 ×4 → 3416 × 1920	0,65 fps, 0,1 vCPU	0,15 fps, 3,8 vCPU	unos 7 min 40 s
Real-ESRGAN animevideov3 ×2 → 1708 × 960	0,65 fps	—	unos 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 fotogramas de salida por segundo), 0,2 vCPU	1,1 fps, 3,1 vCPU	41 s
Real-ESRGAN x4plus (modelo de fotos) ×4	0,02 fps (48 s por fotograma)	—	unas 4 horas

Para comparar Real-ESRGAN con una herramienta de CPU que sí está optimizada para la CPU, también ejecutamos el script de vídeo PyTorch oficial en las 4 vCPU: 0,60 fotogramas por segundo, casi la velocidad de la GPU, pero con todo el servidor ocupado (3,8 vCPU). Para Anime4K y RIFE no existe una herramienta de CPU así: sin GPU, Video2X recurre a Vulkan por software y es 6 veces más lento.

Consejos prácticos a partir de estas cifras:

• Para dibujos animados y anime, empieza con Anime4K: casi en tiempo real en 1080p, y el resultado es limpio.
• Usa el modelo animevideov3 de Real-ESRGAN para vídeo, nunca el modelo de fotos (x4plus): a 48 segundos por fotograma, un clip de 10 segundos se convierte en un trabajo de cuatro horas.
• RIFE es barato: 41 segundos para pasar un clip 480p de 10 segundos de 30 a 60 fotogramas por segundo.
• Los vídeos largos son un trabajo para la noche. A 0,65 fotogramas por segundo, un episodio de 20 minutos a 30 fotogramas por segundo tarda unas 15 horas con Real-ESRGAN. El servidor lo hace mientras duermes; para eso está.

3. Límites

• GPU compartida. La GPU se comparte con otros servidores. Cuando otro servidor la usa, tus trabajos reciben una parte justa pero van más lentos: durante nuestra sesión, la misma foto 1080p tardó 189 s cuando nadie más usaba la GPU y de 226 a 268 s mientras otro servidor la tenía ocupada. Las cifras de arriba son con la GPU sin otro uso.
• Mantén el tamaño de tesela por defecto. Con -t 512, cada trabajo de GPU tardó más de lo que permite el controlador y se detuvo: las imágenes de salida salieron negras. El valor por defecto (automático) o -t 256 funcionan y son igual de rápidos.
• No hay milagros. Una tarjeta RTX de escritorio ejecuta Real-ESRGAN muchas veces más rápido. Si escalas miles de imágenes 4K cada día, alquila una GPU dedicada. Si escalas una fototeca, escaneos antiguos o clips cortos, esto basta.
• La IA inventa detalles. Real-ESRGAN hace que las imágenes parezcan nítidas, pero el nuevo detalle es una suposición. Para documentos, caras que haya que identificar o pruebas, conserva el original.
• La aplicación Upscayl en sí es un programa de escritorio. En un servidor, usa su motor upscayl-bin desde la línea de comandos (abajo), como hace Upscayl detrás de sus botones.

4. ¿Qué plan elegir?

• iGPU Start (2 vCPU, 8 GB de RAM, Perf 1, 14,99 € al mes sin IVA): escalado de fotos con el motor de Upscayl, lotes de imágenes, Anime4K y RIFE en vídeos cortos. Aquí la GPU es 2,2 veces más rápida que las 2 vCPU del plan, y las deja libres.
• iGPU Power (4 vCPU, 14 GB de RAM, Perf 2 = el doble de GPU que Start, 29,99 €): trabajos de Video2X que duran horas, imágenes grandes (de 1080p a 8K) o escalado junto a otros servicios. La mayor parte de GPU importa cuando otros servidores usan la GPU al mismo tiempo.
• iGPU Pro (6 vCPU, 14 GB, Perf 3, 44,99 €): varios trabajos de vídeo largos seguidos, o escalado junto con otros trabajos de GPU (transcodificación, inferencia de IA) en el mismo servidor.

5. Ponerlo en marcha en un servidor Linux GPU

¿Lo quieres listo para usar? Pídelo por correo al hacer el pedido (contact@linuxgpu.eu): podemos entregarte el servidor con upscayl-bin, los modelos de Real-ESRGAN y Video2X ya instalados y probados en la GPU.

Nuestros servidores vienen con el controlador Vulkan de Intel instalado; vulkaninfo --summary debería mostrar la Intel UHD Graphics 770. Después, para imágenes:

# El motor de Upscayl y los modelos de Real-ESRGAN (versiones oficiales)
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

# una foto, 4 veces más grande, en la GPU (-g 0)
$U -i photo.jpg -o photo-x4.png -m realesrgan/models -n realesrgan-x4plus -g 0
# una carpeta entera, modelo de dibujos animados, salida JPEG
$U -i scans/ -o scans-x4/ -m realesrgan/models -n realesrgan-x4plus-anime -g 0 -f jpg

Para vídeo, Video2X 6.4 se distribuye como AppImage. Los servidores no suelen tener FUSE, así que extráelo una vez:

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 busca sus modelos desde aquí
V=../../../AppRun
$V -l                                     # el dispositivo 0 debería ser la Intel UHD 770

# Real-ESRGAN, 2 veces más grande
$V -i ~/clip.mp4 -o ~/clip-x2.mp4 -p realesrgan --realesrgan-model realesr-animevideov3 -s 2 -c libx264 -e crf=18
# Anime4K a 1080p
$V -i ~/clip.mp4 -o ~/clip-1080p.mp4 -p libplacebo --libplacebo-shader anime4k-v4-a -w 1920 -h 1080
# RIFE: de 30 a 60 fotogramas por segundo
$V -i ~/clip.mp4 -o ~/clip-60fps.mp4 -p rife --rife-model rife-v4.6 -m 2

Lanza los trabajos largos dentro de tmux o con nohup para que sigan funcionando cuando cierres la sesión.

Sobre el motor de vídeo de la misma GPU (decodificación y codificación con VA-API), lee Transcodificación de vídeo acelerada: no necesitas una GPU de 500 €/mes y Intel Quick Sync (VAAPI) en un VPS Linux: comandos ffmpeg que funcionan. Para otros modelos de IA en la misma GPU, consulta Inferencia de IA económica: OpenVINO en GPU integrada, sin una GPU de 500 €/mes.

Pruébalo

Ver los planes: iGPU Start cuesta 14,99 € e iGPU Power 29,99 € al mes sin IVA.