Linux GPU

Blog

Upscaling com IA grátis num servidor GPU: Upscayl, Real-ESRGAN e Video2X testados

Corremos o motor do Upscayl (Real-ESRGAN) e o Video2X num servidor na nuvem com uma Intel UHD 770 partilhada, e depois só no CPU. A GPU foi 1,2 a 1,8 vezes mais rápida do que 4 vCPU e 2,2 vezes mais rápida do que 2 vCPU, quase sem usar CPU, e o Video2X correu 4 a 6 vezes mais depressa do que no CPU. Números reais, recortes antes/depois e os comandos.

· Linux GPU

Upscaling com IA grátis num servidor GPU: Upscayl, Real-ESRGAN e Video2X testados

O upscaling com IA transforma uma imagem pequena ou desfocada numa imagem maior e mais nítida: o modelo não se limita a esticar os píxeis, redesenha os pormenores finos, como o cabelo, o pelo ou os contornos de um desenho. Ferramentas pagas como o Topaz fazem-no bem, e os upscalers online fazem-no com limites de envio, filas de espera ou marcas de água. As ferramentas gratuitas e de código aberto são igualmente fáceis de encontrar: o Upscayl (uma aplicação de ambiente de trabalho construída sobre o Real-ESRGAN) e o Video2X para vídeo, que também faz interpolação de fotogramas com RIFE e filtros Anime4K.

Todas correm sobre Vulkan, o que quer dizer que precisam de uma GPU. Por isso perguntámos: num servidor na nuvem com uma GPU Intel partilhada, o que traz realmente a GPU, face ao CPU do mesmo servidor? Usámos os binários oficiais, as mesmas imagens e o mesmo vídeo, e medimos o tempo, o CPU e a memória.

Três recortes do mesmo olho: uma fotografia de 512 píxeis ampliada 4 vezes com escala bicúbica, a mesma fotografia ampliada pelo Real-ESRGAN na GPU, e a fotografia original em alta resolução
Uma fotografia de 512 × 512 ampliada 4 vezes. À esquerda: escala bicúbica clássica. Ao centro: Real-ESRGAN (modelo x4plus) na GPU Intel, 25 segundos. À direita: a fotografia original em alta resolução, para referência. Fotografia: Orren Jack Turner, 1947, domínio público (Wikimedia Commons).

Resultados em resumo

  • Imagens: a GPU é mais rápida e deixa o CPU livre. Ampliar 4 vezes uma fotografia de 512 píxeis demorou 24,9 s na GPU contra 34,0 s em 4 vCPU (1,4 vezes mais rápida) e 55 s em 2 vCPU (2,2 vezes mais rápida). O ensaio na GPU usou 0,1 vCPU; o ensaio no CPU manteve 3,8 vCPU ocupados.
  • As imagens grandes pedem memória no CPU. Ampliar uma fotografia 1080p para 8K demorou 189 s na GPU e 234 s no CPU, e o ensaio no CPU chegou a um pico de 11,8 GB de RAM (1,2 GB com a GPU).
  • O Video2X não tem modo CPU. Forçado a correr no CPU através de Vulkan por software, foi 4 a 6 vezes mais lento: o Anime4K para 1080p correu a 12,2 fotogramas por segundo na GPU contra 1,9, e a duplicação de fotogramas com RIFE a 7,3 contra 1,1.
  • O Real-ESRGAN em vídeo é lento, mesmo na GPU. O modelo rápido para vídeo processou 0,65 fotogramas por segundo: cerca de 8 minutos para um clip de 10 segundos. Serve para um clip curto ou um lote durante a noite, não para um filme.
  • Sejamos honestos quanto ao hardware. Uma GPU integrada é muito mais lenta do que uma placa RTX de computador de secretária. O que interessa é um servidor de 14,99 € que faz o trabalho sem manter o CPU ocupado.

Configuração do teste

ElementoValor
ServidorDebian 13, Linux 7.3, Intel UHD 770 (GPU partilhada), 4 vCPU, 12 GB de RAM
Imagens, GPUupscayl-bin 20251207 (o motor que a aplicação Upscayl chama, versão oficial) com os modelos Real-ESRGAN, Vulkan (Mesa 25.0.7), tamanho de bloco por omissão
Imagens, CPUo código PyTorch oficial do Real-ESRGAN (inference_realesrgan.py, PyTorch 2.15 CPU, fp32, 4 threads; 2 threads fixadas em 2 vCPU para o resultado “2 vCPU”)
VídeoVideo2X 6.4.0 (AppImage oficial), saída H.264 (libx264, CRF 18). CPU: o mesmo Video2X sobre o Vulkan por software do Mesa (llvmpipe), mais o script de vídeo PyTorch oficial para o Real-ESRGAN
Imagenstrês fotografias de 512 × 512, uma fotografia de 1920 × 1080, uma imagem de desenho animado de 854 × 480
Vídeo10 s de Big Buck Bunny em 854 × 480, 30 fotogramas por segundo (300 fotogramas)
Mediçõestempo total incluindo o carregamento do modelo e a escrita do ficheiro, tempo de CPU e pico de memória com /usr/bin/time

Os valores de CPU estão em vCPU (1,0 = um núcleo completo). A GPU é partilhada com outros servidores: verificámos que estava sem outra carga durante os ensaios usados aqui (ver “Limites”).

Material de teste: fotografias da Wikimedia Commons (Albert Einstein por Orren Jack Turner, domínio público; Buzz Aldrin pela NASA, domínio público; um gato por Alvesgaspar, CC BY-SA 3.0) e Big Buck Bunny (© Blender Foundation, CC BY 3.0).

1. Imagens: Real-ESRGAN com o motor do Upscayl

Gráfico de barras: segundos por imagem para o Real-ESRGAN 4x na GPU e em 4 vCPU, para uma fotografia de 512 píxeis, uma imagem de desenho animado e uma imagem de vídeo
Segundos por imagem, ampliada 4 vezes, incluindo o carregamento do modelo. A verde: a GPU Intel com o upscayl-bin. A laranja: o código PyTorch oficial nos 4 vCPU do mesmo servidor.
ImagemModeloGPUCPU, 4 vCPUCPU, 2 vCPU
Fotografia 512 × 512 → 2048 × 2048RealESRGAN x4plus24,9 s, 0,1 vCPU, 1,0 GB34,0 s, 3,8 vCPU, 4,1 GB55,0 s
Fotografia 1920 × 1080 → 7680 × 4320RealESRGAN x4plus189 s, 0,03 vCPU, 1,2 GB234 s, 4,0 vCPU, 11,8 GB—
Desenho animado 854 × 480 → 3416 × 1920x4plus-anime12,9 s, 0,1 vCPU, 0,4 GB17,9 s, 3,6 vCPU, 6,0 GB—
Imagem de vídeo 854 × 480 → 3416 × 1920animevideov3 (rápido)2,2 s, 0,6 vCPU4,0 s, 2,4 vCPU, 0,9 GB—

O tempo da fotografia é a mediana de três fotografias diferentes; todas demoraram entre 24,8 e 25 segundos na GPU.

O que isto significa:

  • Face aos 4 vCPU, a GPU é 1,2 a 1,8 vezes mais rápida. É um ganho real, não um milagre: o modelo de fotografia do Real-ESRGAN é pesado, e quatro núcleos de CPU modernos não são lentos.
  • Face a 2 vCPU, o tamanho do nosso plano Start, a GPU é 2,2 vezes mais rápida. A GPU não encolhe com o plano; o CPU sim.
  • A GPU deixa o servidor livre. Durante um ensaio na GPU, o CPU do servidor fica em cerca de 0,1 vCPU: pode correr ao mesmo tempo uma aplicação web, uma galeria ou um segundo trabalho. No CPU, o upscaling ocupa tudo.
  • Memória. Sem divisão em blocos, o código PyTorch precisou de 11,8 GB de RAM para a fotografia 1080p. Num servidor de 8 GB teria de dividir a imagem em blocos também no CPU, o que o torna ainda mais lento.
Três recortes da cara de um gato: ampliação bicúbica 4x, Real-ESRGAN 4x na GPU, e a fotografia original
O mesmo teste com um gato: bicúbica (à esquerda), Real-ESRGAN x4plus na GPU (ao centro), fotografia original (à direita). O Real-ESRGAN devolve um pelo e uns bigodes nítidos; também inventa alguns pormenores, por isso compare com o original quando a exatidão é importante. Fotografia: Alvesgaspar, Wikimedia Commons, CC BY-SA 3.0.
Dois recortes de um esquilo de desenho animado: ampliação bicúbica 4x à esquerda, Real-ESRGAN animevideov3 na GPU à direita com contornos mais nítidos
Uma imagem de desenho animado em 480p ampliada 4 vezes: bicúbica (à esquerda) e o modelo rápido para vídeo do Real-ESRGAN na GPU (à direita, 2,2 s). Linhas limpas, cores uniformes. Big Buck Bunny, © Blender Foundation, CC BY 3.0.

2. Vídeo: Video2X com Real-ESRGAN, Anime4K e RIFE

O Video2X lê um vídeo, passa cada fotograma por um filtro na GPU e codifica o resultado com o FFmpeg. Oferece três tipos de trabalho: Real-ESRGAN (upscaling com IA, lento, melhor qualidade), Anime4K (shaders GLSL rápidos para desenhos animados, através do libplacebo) e RIFE (interpolação de fotogramas com IA: de 30 para 60 fotogramas por segundo).

Gráfico de barras: fotogramas por segundo do Video2X na GPU e no CPU para o Real-ESRGAN x4, o Anime4K para 1080p e a duplicação de fotogramas com RIFE
Fotogramas de origem processados por segundo pelo Video2X 6.4. A verde: GPU Intel. A laranja: o mesmo Video2X forçado a correr no CPU (Vulkan por software do Mesa), com os 4 vCPU.
Trabalho Video2X (origem 854 × 480)GPUCPU (Vulkan por software)Clip de 10 segundos na GPU
Real-ESRGAN animevideov3 ×4 → 3416 × 19200,65 fps, 0,1 vCPU0,15 fps, 3,8 vCPUcerca de 7 min 40 s
Real-ESRGAN animevideov3 ×2 → 1708 × 9600,65 fps—cerca de 7 min 40 s
Anime4K → 1920 × 108012,2 fps, 0,7 vCPU1,9 fps, 3,1 vCPU25 s
Anime4K → 3840 × 21607,4 fps, 1,5 vCPU—40 s
RIFE v4.6, 30 → 60 fps7,3 fps (14,6 fotogramas produzidos por segundo), 0,2 vCPU1,1 fps, 3,1 vCPU41 s
Real-ESRGAN x4plus (modelo de fotografia) ×40,02 fps (48 s por fotograma)—cerca de 4 horas

Para comparar o Real-ESRGAN com uma ferramenta realmente otimizada para o CPU, corremos também o script de vídeo PyTorch oficial nos 4 vCPU: 0,60 fotogramas por segundo, quase a velocidade da GPU, mas com o servidor inteiro ocupado (3,8 vCPU). Para o Anime4K e o RIFE não existe uma ferramenta assim para o CPU: sem GPU, o Video2X recorre ao Vulkan por software e fica 6 vezes mais lento.

Cinco segundos de Big Buck Bunny em 480p, ampliados 2 vezes. À esquerda: bicúbica. À direita: Real-ESRGAN (animevideov3) com o Video2X na GPU: relva e folhas mais nítidas. Big Buck Bunny, © Blender Foundation, CC BY 3.0.

Conselhos práticos a partir destes números:

  • Para desenhos animados e anime, comece pelo Anime4K: quase em tempo real em 1080p, e o resultado é limpo.
  • Use o modelo animevideov3 do Real-ESRGAN para vídeo, nunca o modelo de fotografia (x4plus): com 48 segundos por fotograma, um clip de 10 segundos passa a ser um trabalho de quatro horas.
  • O RIFE é barato: 41 segundos para passar um clip de 10 segundos em 480p de 30 para 60 fotogramas por segundo.
  • Os vídeos longos são trabalho para a noite. A 0,65 fotogramas por segundo, um episódio de 20 minutos a 30 fotogramas por segundo demora cerca de 15 horas com o Real-ESRGAN. O servidor faz o trabalho enquanto dorme; é para isso que serve.

3. Limites

  • GPU partilhada. A GPU é partilhada com outros servidores. Quando outro servidor a usa, os seus trabalhos recebem uma parte justa, mas correm mais devagar: durante a nossa sessão, a mesma fotografia 1080p demorou 189 s com a GPU sem outra carga, e 226 a 268 s enquanto outro servidor a ocupava. Os números acima foram medidos com a GPU sem outra carga.
  • Mantenha o tamanho de bloco por omissão. Com -t 512, cada trabalho na GPU demorou mais do que o controlador permite e foi interrompido: as imagens de saída ficaram pretas. O valor por omissão (automático) ou -t 256 funcionam e são igualmente rápidos.
  • Sem milagres. Uma placa RTX de computador de secretária corre o Real-ESRGAN muitas vezes mais depressa. Se amplia milhares de imagens 4K por dia, alugue uma GPU dedicada. Se amplia uma biblioteca de fotografias, digitalizações antigas ou clips curtos, isto chega.
  • A IA inventa pormenores. O Real-ESRGAN dá um aspeto nítido às imagens, mas os novos pormenores são uma suposição. Para documentos, rostos que tem de identificar ou provas, guarde o original.
  • A aplicação Upscayl em si é um programa de ambiente de trabalho. Num servidor, use o seu motor upscayl-bin na linha de comandos (ver abaixo), como o Upscayl faz por trás dos seus botões.

4. Que plano escolher?

  • iGPU Start (2 vCPU, 8 GB de RAM, Perf 1, 14,99 € s/ IVA por mês): upscaling de fotografias com o motor do Upscayl, lotes de imagens, Anime4K e RIFE em vídeos curtos. Aqui a GPU é 2,2 vezes mais rápida do que os 2 vCPU do plano, e deixa-os livres.
  • iGPU Power (4 vCPU, 14 GB de RAM, Perf 2 = o dobro da parte de GPU do Start, 29,99 €): trabalhos Video2X que duram horas, imagens grandes (1080p para 8K), ou upscaling ao lado de outros serviços. A parte de GPU maior conta quando outros servidores usam a GPU ao mesmo tempo.
  • iGPU Pro (6 vCPU, 14 GB, Perf 3, 44,99 €): vários trabalhos de vídeo longos seguidos, ou upscaling juntamente com outro trabalho de GPU (transcodificação, inferência de IA) no mesmo servidor.

5. Configurar num servidor Linux GPU

Quer o servidor pronto a usar? Peça-o por e-mail ao encomendar (contact@linuxgpu.eu): podemos entregar-lhe o servidor com o upscayl-bin, os modelos Real-ESRGAN e o Video2X já instalados e testados na GPU.

Os nossos servidores vêm com o controlador Vulkan da Intel instalado; vulkaninfo --summary deve mostrar a Intel UHD Graphics 770. Depois, para imagens:

# O motor do Upscayl e os modelos Real-ESRGAN (versões oficiais)
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

# uma fotografia, 4 vezes maior, na GPU (-g 0)
$U -i photo.jpg -o photo-x4.png -m realesrgan/models -n realesrgan-x4plus -g 0
# uma pasta inteira, modelo para desenhos animados, saída em JPEG
$U -i scans/ -o scans-x4/ -m realesrgan/models -n realesrgan-x4plus-anime -g 0 -f jpg

Para vídeo, o Video2X 6.4 é distribuído como AppImage. Os servidores normalmente não têm FUSE, por isso extraia-o uma 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       # o Video2X procura os modelos a partir daqui
V=../../../AppRun
$V -l                                     # o dispositivo 0 deve ser a Intel UHD 770

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

Corra os trabalhos longos dentro do tmux ou com nohup, para que continuem depois de terminar a sessão.

Para o motor de vídeo da mesma GPU (descodificação e codificação com VA-API), leia Transcodificação de vídeo acelerada: não precisa de uma GPU de 500 €/mês e o nosso guia rápido Intel Quick Sync (VAAPI) num VPS Linux: comandos ffmpeg que funcionam. Para outros modelos de IA na mesma GPU, veja Inferência de IA económica: OpenVINO em GPU integrada, sem GPU de 500 €/mês.

Experimentar

Ver os planos: o iGPU Start custa 14,99 € e o iGPU Power 29,99 € s/ IVA por mês.

Leitura relacionada