Cómo Eliminar el Fondo de Imágenes Automáticamente con Python y rembg

¿Alguna vez has necesitado eliminar el fondo de múltiples imágenes y encontraste que hacerlo manualmente en Photoshop o herramientas online es tedioso y consume mucho tiempo? En este tutorial te mostraré cómo automatizar este proceso usando Python y rembg, una librería potente que utiliza modelos de IA para remover fondos con precisión profesional.

¿Qué es rembg?

rembg es una librería de Python que utiliza modelos de deep learning (específicamente U2-Net) para eliminar fondos de imágenes de forma automática. Lo mejor de todo es que:

• ✅ No requiere conocimientos de Machine Learning
• ✅ Funciona offline (una vez descargado el modelo)
• ✅ Resultados profesionales en segundos
• ✅ Soporta múltiples formatos (PNG, JPG, WEBP, etc.)
• ✅ Gratis y open source

Requisitos Previos

Antes de comenzar, asegúrate de tener:

• Python 3.8 o superior instalado
• Conocimientos básicos de Python
• pip para instalar paquetes

Instalación

Paso 1: Instalar las librerías necesarias

Abre tu terminal o línea de comandos y ejecuta:

pip install rembg pillow

¿Qué estamos instalando?

• rembg: La librería principal para eliminar fondos
• pillow: Para manipulación adicional de imágenes (PIL)

Paso 2: Instalar onnxruntime (motor de inferencia)

Dependiendo de tu sistema, necesitarás uno de estos:

Para CPU (la mayoría de usuarios):

pip install onnxruntime

Para GPU NVIDIA (si tienes GPU CUDA):

pip install onnxruntime-gpu

Script Básico: Tu Primera Imagen sin Fondo

Empecemos con un script simple para procesar una sola imagen:

from rembg import remove
from PIL import Image
import os

def remove_background_simple(input_path, output_path):
    """
    Elimina el fondo de una imagen
    
    Args:
        input_path: Ruta de la imagen original
        output_path: Ruta donde guardar la imagen sin fondo
    """
    # Abrir la imagen
    input_image = Image.open(input_path)
    
    # Remover el fondo
    output_image = remove(input_image)
    
    # Guardar la imagen con fondo transparente
    output_image.save(output_path)
    
    print(f"✅ Imagen procesada: {output_path}")

# Ejemplo de uso
remove_background_simple('foto.jpg', 'foto_sin_fondo.png')

¡Así de simple! Con solo 3 líneas de código útil, ya tienes una imagen con fondo transparente.

Script Avanzado: Procesamiento por Lotes

Ahora vamos a crear un script más robusto que procese múltiples imágenes, cree respaldos y maneje errores:

from rembg import remove
from PIL import Image
import os
from pathlib import Path

def remove_background_batch(directory, file_pattern="*.png"):
    """
    Procesa todas las imágenes en un directorio
    
    Args:
        directory: Carpeta con las imágenes
        file_pattern: Patrón de archivos a procesar (ej: "*.jpg", "*.png")
    """
    directory_path = Path(directory)
    
    # Encontrar todas las imágenes que coincidan con el patrón
    image_files = list(directory_path.glob(file_pattern))
    
    if not image_files:
        print(f"❌ No se encontraron imágenes con el patrón {file_pattern}")
        return
    
    print(f"📁 Encontradas {len(image_files)} imágenes para procesar\n")
    
    for image_path in image_files:
        try:
            # Crear nombre de archivo de respaldo
            backup_path = image_path.with_name(f"{image_path.stem}_backup{image_path.suffix}")
            
            # Crear respaldo del original
            if not backup_path.exists():
                print(f"💾 Creando respaldo: {backup_path.name}")
                Image.open(image_path).save(backup_path)
            
            # Nombre temporal para la imagen sin fondo
            temp_output = image_path.with_name(f"{image_path.stem}_nobg.png")
            
            # Procesar imagen
            print(f"🔄 Procesando: {image_path.name}")
            input_image = Image.open(image_path)
            
            # Obtener tamaño original
            original_size = os.path.getsize(image_path)
            
            # Remover fondo
            output_image = remove(input_image)
            
            # Guardar temporalmente
            output_image.save(temp_output, format='PNG')
            
            # Obtener tamaño nuevo
            new_size = os.path.getsize(temp_output)
            
            # Reemplazar archivo original
            os.remove(image_path)
            os.rename(temp_output, image_path)
            
            # Mostrar resultados
            size_diff = (original_size - new_size) / 1024  # KB
            print(f"✅ Completado: {image_path.name}")
            print(f"   Tamaño original: {original_size/1024:.1f} KB")
            print(f"   Tamaño nuevo: {new_size/1024:.1f} KB")
            print(f"   {'Reducción' if size_diff > 0 else 'Aumento'}: {abs(size_diff):.1f} KB\n")
            
        except Exception as e:
            print(f"❌ Error procesando {image_path.name}: {str(e)}\n")
            continue
    
    print("🎉 ¡Proceso completado!")

# Ejemplo de uso
if __name__ == "__main__":
    # Procesar todas las imágenes PNG en la carpeta 'avatares'
    remove_background_batch("public/avatar", "*.png")

Características del Script Avanzado

🔒 Respaldos Automáticos

El script crea automáticamente copias de seguridad con el sufijo _backup antes de procesar las imágenes.

📊 Información Detallada

Muestra:

• Número de imágenes encontradas
• Progreso en tiempo real
• Tamaños de archivo antes y después
• Diferencia en KB

🛡️ Manejo de Errores

Si una imagen falla, el script continúa con las demás sin interrumpirse.

🎯 Filtrado Flexible

Puedes especificar qué tipo de archivos procesar usando patrones como:

• "*.jpg" - Solo archivos JPG
• "*.png" - Solo archivos PNG
• "avatar_*.png" - Solo PNGs que empiecen con "avatar_"

Casos de Uso Reales

1. Avatares para Sitio Web

# Procesar avatares de equipo
remove_background_batch("team_photos", "*.jpg")

2. Productos para E-commerce

# Procesar fotos de productos
remove_background_batch("products", "*.png")

3. Imágenes para Presentaciones

# Procesar imágenes para slides
remove_background_batch("presentation_images", "*.jpg")

Optimizaciones y Tips

💡 Tip 1: Calidad de la Imagen Original

Mejores resultados con:

• Buena iluminación
• Contraste claro entre sujeto y fondo
• Imágenes de alta resolución

💡 Tip 2: Formato de Salida

Siempre guarda como PNG para preservar la transparencia:

output_image.save(output_path, format='PNG')

💡 Tip 3: Modelos Alternativos

rembg ofrece diferentes modelos. Para usar uno específico:

from rembg import remove

output = remove(input_image, model_name='u2net_human_seg')  # Optimizado para personas

Modelos disponibles:

• u2net - General (default)
• u2net_human_seg - Optimizado para personas
• u2netp - Versión ligera y rápida
• silueta - Para siluetas

💡 Tip 4: Procesamiento en GPU

Si tienes GPU NVIDIA con CUDA:

# Instalar versión GPU
pip install onnxruntime-gpu

# El código es el mismo, pero será mucho más rápido

Comparación con Alternativas

Mi Experiencia Personal

❌ ANTES (con fondo)

864KB

✅ DESPUÉS (sin fondo)

352KB (-59%)

👨‍💻 Developer

❌ ANTES

1.1MB

✅ DESPUÉS

554KB (-50%)

�‍☠️ Pirata

❌ ANTES

1.1MB

✅ DESPUÉS

584KB (-47%)

🚀 Astronauta

❌ ANTES

1.0MB

✅ DESPUÉS

426KB (-57%)

👨‍🍳 Chef

❌ ANTES

1.1MB

✅ DESPUÉS

437KB (-60%)

💻 Programador

❌ ANTES

1.2MB

✅ DESPUÉS

551KB (-54%)

🗺️ Cazador de Tesoros

Solución de Problemas Comunes

Error: "No module named 'onnxruntime'"

Solución:

pip install onnxruntime

Error: "Could not find model"

Solución: El modelo se descarga automáticamente la primera vez. Asegúrate de tener conexión a internet.

Resultados con bordes pixelados

Solución: Usa una imagen de mayor resolución o prueba con el modelo u2net (default).

Muy lento en CPU

Solución:

• Usa el modelo u2netp (más rápido pero menos preciso)
• Considera usar GPU con onnxruntime-gpu

Código Completo del Proyecto

Puedes encontrar el código completo y ejemplos adicionales en mi repositorio:

git clone https://github.com/judmontoyaso/curriculum
cd curriculum
# Los scripts están en: remove_background.py y remove_bg_new.py

Próximos Pasos

Ahora que dominas la eliminación de fondos con Python, puedes:

1. Integrar en un pipeline de automatización con N8N o Zapier
2. Crear una API REST con Flask/FastAPI para usar desde cualquier aplicación
3. Construir una interfaz web con Streamlit o Gradio
4. Procesar en lote miles de imágenes con scripts programados

Conclusión

• ✅ Rápido: Segundos por imagen
• ✅ Preciso: Resultados profesionales usando IA
• ✅ Escalable: Procesa miles de imágenes sin esfuerzo
• ✅ Gratis: Sin límites ni suscripciones

Recursos Adicionales

• 📚 Documentación oficial de rembg
• 🎓 Pillow Documentation
• 💻 Mi repositorio con ejemplos