Notas del proyecto rembg: una herramienta de eliminación de fondo local

Sun, 19 Apr 2026 08:56:01 +0800

rembg es una herramienta de eliminación de fondo de imágenes. Se puede utilizar como herramienta de línea de comandos, biblioteca de Python, servidor HTTP o contenedor Docker. Su propósito es sencillo: tomar una imagen como entrada y generar el primer plano con un canal alfa. Funciona bien para imágenes de productos, retratos, procesamiento de materiales y flujos de trabajo de imágenes automatizados.

La mejor parte es que puede ejecutarse localmente. Si no desea cargar imágenes de origen a un servicio de recorte en línea, necesita procesamiento por lotes o desea conectar la eliminación de fondo a scripts y sistemas comerciales, rembg es más fácil de automatizar que una herramienta web.

01 Instalación

La versión actual requiere Python >=3.11,<3.14. Elija el backend según su hardware:

`1`	`pip install "rembg[cpu]"`

Si necesita la CLI, agregue cli:

`1`	`pip install "rembg[cpu,cli]"`

Para entornos NVIDIA CUDA, instale la versión GPU:

`1`	`pip install "rembg[gpu,cli]"`

Para entornos AMD ROCm, primero instale onnxruntime-rocm siguiendo las instrucciones oficiales de ROCm, luego instale:

`1`	`pip install "rembg[rocm,cli]"`

La mayoría de los problemas con la versión de GPU no están en rembg en sí, sino en si coinciden onnxruntime-gpu, CUDA, cuDNN y las versiones del controlador. Si la instalación falla, primero confirme el flujo de trabajo con la versión de la CPU y luego ocúpese del entorno de la GPU.

02 Subcomandos CLI

Después de instalar la CLI, puede usar rembg directamente en la terminal. Proporciona principalmente 4 subcomandos:

i: procesa un solo archivo.
p: procesa una carpeta completa.
s: inicia un servidor HTTP.
b: procesa un flujo binario RGB de 24 píxeles, utilizado a menudo con FFmpeg.

Mostrar ayuda:

1
2

rembg --help
rembg i --help

Procese una única imagen local:

`1`	`rembg i input.png output.png`

Tubería en una imagen remota:

`1`	`curl -s http://input.png \| rembg i > output.png`

Especifique un modelo:

`1`	`rembg i -m u2netp input.png output.png`

Devuelve sólo la máscara:

`1`	`rembg i -om input.png mask.png`

Habilitar estera alfa:

`1`	`rembg i -a input.png output.png`

-a a veces puede producir cabello más natural, bordes borrosos y límites semitransparentes, pero es más lento y no mejora notablemente todas las imágenes.

03 Carpetas de procesamiento por lotes

El procesamiento por lotes es una de las partes más útiles de “rembg”. Coloque las imágenes de origen en un directorio y envíe los resultados a otro:

`1`	`rembg p path/to/input path/to/output`

Esté atento a los cambios de directorio y procese automáticamente imágenes nuevas o modificadas:

`1`	`rembg p -w path/to/input path/to/output`

Este modo funciona bien con scripts de descarga, limpieza de imágenes de productos y carpetas de materiales. Por ejemplo, suelte imágenes en “entrada” y deje que “rembg” genere archivos PNG transparentes en “salida”.

04 Utilizándolo como biblioteca de Python

Si desea integrarlo en su propio script, la forma más sencilla es “eliminar”:

from rembg import remove

with open("input.png", "rb") as i:
    with open("output.png", "wb") as o:
        input_data = i.read()
        output_data = remove(input_data)
        o.write(output_data)

También puedes procesar imágenes PIL directamente:

from rembg import remove
from PIL import Image

input_image = Image.open("input.png")
output_image = remove(input_image)
output_image.save("output.png")

Para el procesamiento por lotes, reutilice una sesión para que el modelo no se inicialice nuevamente para cada imagen:

from pathlib import Path
from rembg import remove, new_session

session = new_session()

for file in Path("input").glob("*.png"):
    output = file.parent / f"{file.stem}.out.png"
    with open(file, "rb") as i:
        with open(output, "wb") as o:
            o.write(remove(i.read(), session=session))

Si está creando un servicio de procesamiento de imágenes de larga duración, la reutilización de sesiones suele ser una mejor opción que llamar repetidamente a la CLI.

05 Iniciando un servidor HTTP

rembg también puede iniciar un servidor HTTP directamente:

`1`	`rembg s --host 0.0.0.0 --port 7000 --log_level info`

Después del inicio, visite:

`1`	`http://localhost:7000/api`

Eliminar el fondo de una URL:

`1`	`curl -s "http://localhost:7000/api/remove?url=http://input.png" -o output.png`

Sube una imagen local:

`1`	`curl -s -F file=@input.jpg "http://localhost:7000/api/remove" -o output.png`

Si solo necesita la API y no necesita la interfaz de usuario de Gradio, desactive la interfaz de usuario para reducir el uso inactivo de la CPU:

`1`	`rembg s --no-ui`

El modo servidor es adecuado para herramientas internas, flujos de automatización u otras aplicaciones. Pero no es un sistema completo de gestión de activos de imágenes. La autenticación, la limitación de velocidad, las colas y la limpieza de archivos aún deben gestionarse fuera de él.

06 Uso de Docker

La versión de CPU puede usar la imagen oficial directamente:

`1`	`docker run -v .:/data danielgatis/rembg i /data/input.png /data/output.png`

La aceleración CUDA requiere NVIDIA Container Toolkit en el host y, por lo general, requiere crear una imagen a partir del Dockerfile_nvidia_cuda_cudnn_gpu del proyecto:

`1`	`docker build -t rembg-nvidia-cuda-cudnn-gpu -f Dockerfile_nvidia_cuda_cudnn_gpu .`

Ejecutar ejemplo:

docker run --rm -it --gpus all \
  -v /dev/dri:/dev/dri \
  -v $PWD:/data \
  rembg-nvidia-cuda-cudnn-gpu \
  i -m birefnet-general /data/input.png /data/output.png

El archivo README oficial señala que la imagen de la GPU es mucho más grande que la imagen de la CPU y los archivos del modelo no están incluidos en la imagen. Para evitar descargar modelos repetidamente, monte el directorio del modelo:

`1`	`docker run -v /path/to/models:/root/.u2net ...`

07 Opciones de modelo

Cuando rembg usa un modelo por primera vez, lo descarga automáticamente a ~/.u2net/. Los modelos comunes incluyen:

u2net: un modelo de propósito general para casos comunes.
u2netp: una versión ligera con velocidad y tamaño más amigables.
u2net_human_seg: enfocado a la segmentación humana.
u2net_cloth_seg: enfocado al análisis de ropa.
silueta: similar a u2net, pero más pequeña.
isnet-general-use: un modelo más nuevo de propósito general.
isnet-anime: enfocado a la segmentación de personajes de anime.
birefnet-general: un modelo de imagen general utilizado en el ejemplo README.
sam: puede trabajar con parámetros adicionales como puntos de aviso.

En la práctica, no elijas sólo por el nombre del modelo. Las imágenes de productos, los retratos, las imágenes de anime, los fondos complejos y los objetos transparentes tienen requisitos diferentes. Un enfoque más seguro es elegir un conjunto de imágenes representativo, ejecutar varios modelos, comparar bordes, áreas omitidas, eliminaciones falsas y velocidad, y luego decidir el modelo predeterminado.

Si desea utilizar un modelo .onnx personalizado, colóquelo en el directorio del modelo predeterminado ~/.u2net/ y configúrelo cuando sea necesario:

`1`	`MODEL_CHECKSUM_DISABLED=1`

Esto puede evitar que rembg sobrescriba su archivo de modelo debido a la lógica de suma de comprobación.

08 Casos de uso adecuados

rembg se adapta bien a estas tareas:

Generar por lotes imágenes de productos con fondo transparente.
Extraiga primeros planos de retratos, fotografías de identificación e imágenes de materiales.
Integre la eliminación de fondo en scripts de Python o servicios backend.
Implementar una API de eliminación de fondo simple en una red interna.
Utilice tuberías FFmpeg para procesar fotogramas de vídeo o secuencias de imágenes.
Mantenga los materiales sensibles a la privacidad o protegidos por derechos de autor lejos de los servicios en línea de terceros.

Es menos adecuado para estos casos:

Necesita bordes retocados a mano y materiales transparentes complejos.
Cada imagen debe alcanzar una calidad de fotografía comercial estable.
Quieres una herramienta de diseño en línea completa en lugar de solo eliminar el fondo.
No desea mantener un entorno Python o Docker.
Su entorno de controlador de GPU, CUDA o ROCm ya está desordenado y el proyecto debe iniciarse rápidamente.

09 Consejos de uso

Si solo procesa imágenes ocasionalmente, la versión de la CPU es suficiente:

`1`	`pip install "rembg[cpu,cli]"`

Para procesar por lotes miles de imágenes, considere:

Reutilizar una sesión de Python.
Arreglando el directorio del modelo para evitar descargas repetidas.
Uso de un SSD para entradas, salidas y archivos de modelo.
Probar primero la calidad del modelo en un lote pequeño.
Decidir si la aceleración de la GPU vale la pena después.

El valor de la GPU es principalmente el rendimiento por lotes. Para el procesamiento ocasional de una sola imagen, el costo de configuración puede ser mayor que el tiempo ahorrado. Especialmente en Windows, cuando las versiones CUDA, cuDNN y onnxruntime-gpu no coinciden, la versión de CPU puede ser la opción más práctica.

10 toma rápida

rembg es simple, de código abierto y flexible: puede ejecutarse como una CLI, llamarse desde Python, exponer puntos finales HTTP o empaquetarse con Docker. Es un buen componente base para la eliminación automática del fondo local.

Pero no es un borrador mágico. Los fondos complejos, los bordes finos del sujeto, los materiales transparentes, la preservación de las sombras y los retoques de calidad comercial aún pueden requerir trabajo manual o un flujo de trabajo más especializado. Al implementar la automatización por lotes, es mejor realizar una revisión humana o un paso de recuperación de muestras fallidas.

Si el objetivo es eliminar fondos de un lote de imágenes rápidamente manteniendo el proceso local, vale la pena mantener “rembg” en la caja de herramientas.

Enlaces relacionados

Proyecto GitHub: https://github.com/danielgatis/rembg
LÉAME: https://github.com/danielgatis/rembg/blob/main/README.md
Lanzamientos: https://github.com/danielgatis/rembg/releases
Matriz de instalación de ONNX Runtime: https://onnxruntime.ai/

Rembg on KnightLi Blog