Docker on KnightLi Blog

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/

Guía práctica de codex-quota: uso local, web y de Docker con comandos CLI originales

Thu, 16 Apr 2026 18:13:04 +0800

Qué hace este proyecto

codex-quota es una herramienta liviana para verificar el uso de la cuota de ChatGPT Codex, con datos obtenidos de https://chatgpt.com/backend-api/wham/usage.

Características principales:

Admite consultas de una sola cuenta y de varias cuentas (account/*.auth.json).
Genera five_hour%, weekly%, weekly_reset y marca la fuente (network o cache).
Utiliza reintentos de retroceso exponencial para fallas temporales (408, 429, 5xx).
Incluye almacenamiento en caché local para reducir las solicitudes repetidas cuando la cuota ya está agotada.
Proporciona un panel web, API JSON y páginas de administración de archivos de autenticación.

Ventajas:

Ligero: se ejecuta con scripts simples y dependencias mínimas.
Práctico: admite puntos de entrada CLI y Web.
Implementable: funciona con Docker y Docker Compose.
Fácil de operar: incluye reintento, caché y soporte de actualización programada.

Prepare las credenciales de la cuenta primero

Cree archivos de credenciales en account/<name>.auth.json, por ejemplo:

{
  "tokens": {
    "access_token": "eyJ...",
    "account_id": "user-xxxxxxxx"
  }
}

Explicación:

La API de uso requiere access_token y account_id.
<nombre> en el nombre del archivo se utiliza como nombre de cuenta en la salida.

Uso de CLI local (conservar los comandos originales)

Instalar dependencias:

`1`	`pip install -r requirements.txt`

Explicación: instala las dependencias del proyecto.

Consultar todas las cuentas:

`1`	`python codex_quota.py`

Explicación: lee account/*.auth.json y genera un resumen de cuota para todas las cuentas.

Consulta una cuenta:

`1`	`python codex_quota.py your_account_name`

Explicación: solo consulta cuenta/nombre_de_cuenta.auth.json.

Forzar actualización (omitir caché):

`1`	`python codex_quota.py --refresh`

Explicación: ignora el caché local y recupera datos nuevos directamente.

Opciones CLI (alineadas con README)

account_name: nombre de cuenta opcional (sin .auth.json).
--account-dir: directorio de autenticación, cuenta predeterminada.
--chatgpt-url: punto final de API de cuota.
--raw-json: imprime el cuerpo completo de la respuesta JSON.
--raw-headers: imprime encabezados de respuesta.
--refresh: ignora el caché.
--retries: recuento de reintentos, valor predeterminado 3.
--retry-delay: retraso de reintento base en segundos, valor predeterminado 2.0.

Uso del panel web (conservar el comando original)

Iniciar el servicio:

`1`	`python codex_quota_service.py --host 0.0.0.0 --port 8081`

Explicación: inicia el servicio HTTP escuchando en el puerto 8081.

URL de acceso: http://localhost:8081

Opciones de servicio:

--host: dirección de enlace, predeterminado 0.0.0.0.
--port: puerto de servicio, predeterminado 8081.
--interval-segundos: intervalo de actualización programado, predeterminado 3600.
--account-dir: directorio de autenticación, cuenta predeterminada.
--state-file: ruta del archivo de estado, predeterminado <account-dir>/codex_quota_web_results.json.
--account-name: modo de cuenta única opcional.
--chatgpt-url: punto final de API de cuota.
--retries: recuento de reintentos.
--retry-delay: retraso de reintento base.
--refresh: ignora el caché CLI durante las ejecuciones programadas.

Puntos finales HTTP (para automatización)

GET /: página del panel de control.
GET /api/results: últimos resultados en JSON.
GET /refresh: activa la actualización inmediata y redirige a /.
GET /auth: enumera los archivos de autenticación.
GET /auth/new: formulario para crear un archivo de autenticación.
GET /auth/edit?name=<cuenta>: formulario para editar el archivo de autenticación.
POST /auth/save: crea/actualiza el archivo de autenticación.
POST /auth/delete: elimina el archivo de autenticación.

Uso de Docker (conservar los comandos originales)

Construir imagen:

`1`	`docker build -t codex-quota .`

Explicación: construye el proyecto actual como imagen codex-quota.

Ejecutar contenedor (mapa 8081):

`1`	`docker run --rm -p 8081:8081 -v ./account:/app/account codex-quota`

Explicación:

--rm: elimina el contenedor automáticamente después de salir.
-p 8081:8081: asigna el puerto del host al puerto del contenedor.
-v ./account:/app/account: monta las credenciales locales en el contenedor.

URL de acceso: http://localhost:8081

Uso de Docker Compose (conservar el comando original)

Inicio:

`1`	`docker compose up --build`

Explicación: cree e inicie servicios basados en docker-compose.yml.

URL de acceso: http://localhost:8081

Consejos de uso

Para escenarios de múltiples cuentas, use primero el Panel de control para una vista unificada y administración de autenticación.
Para alertas o automatización, prefiera GET /api/results.
No envíe valores reales de access_token a repositorios públicos.
Si ve muchas fallas temporales, aumente --retries y --retry-delay.

Cree imágenes de Docker en VS Code en Windows: desde la configuración hasta la compilación

Thu, 16 Apr 2026 10:20:00 +0800

Si desea crear imágenes de Docker directamente desde VS Code en Windows, el flujo de trabajo es sencillo. Solo necesitas tres partes: preparar el entorno, crear un Dockerfile y luego ejecutar la compilación.

01 Requisitos previos

Asegúrese de que estos dos elementos estén listos:

Instale y ejecute Docker Desktop.
Instale la extensión oficial de Microsoft Docker en VS Code.

En Windows, usar el backend WSL 2 en Docker Desktop (Configuración > Recursos > Integración WSL) suele ser más estable y rápido.

02 Preparar un archivo Docker

Si tu proyecto aún no tiene uno, VS Code puede generarlo:

Abra la carpeta de su proyecto en VS Code.
Presione F1 o Ctrl+Shift+P para abrir la paleta de comandos.
Ejecute Docker: Agregar archivos Docker al espacio de trabajo.
Elija su plataforma (Node.js, Python, .NET, etc.) y siga las indicaciones.

Normalmente obtendrá al menos:

-Dockerfile

.dockerignore

Esto le proporciona una base de trabajo que podrá perfeccionar más adelante.

03 Tres Maneras de Construir la Imagen

Método A: haga clic con el botón derecho en Dockerfile

En el Explorador de archivos, haga clic derecho en “Dockerfile”, seleccione “Crear imagen…” e ingrese una etiqueta de imagen.

Método B: Paleta de comandos

Presione F1, ejecute Docker: Build Image, luego seleccione el contexto y la etiqueta.

Método C: Terminal integrado

`1`	`docker build -t your-image-name .`

Este comando crea una imagen a partir del contexto del directorio actual con la etiqueta tu-nombre-de-imagen.

04 Comprobaciones rápidas para problemas comunes

Docker Desktop no se está ejecutando: verifique que esté iniciado.
La compilación es muy lenta: verifique si el backend de WSL 2 está habilitado.
La compilación no puede encontrar archivos: asegúrese de que su terminal esté en la raíz del proyecto y que los archivos estén dentro del contexto de compilación.
Los recursos de Docker no se muestran en VS Code: reinicie VS Code y verifique Docker CLI (versión de Docker).

Resumen

La creación de imágenes de Docker en VS Code en Windows es principalmente un problema de configuración. Una vez que Docker Desktop y la extensión VS Code Docker estén implementados, puede generar archivos Docker rápidamente y crear imágenes desde la interfaz de usuario o el terminal.