Hapus background banyak gambar dengan Python: rembg vs API

Anda punya satu folder berisi beberapa ratus foto produk, foto profil, atau gambar listing, dan semuanya perlu dihapus background-nya. Mengerjakannya satu per satu di aplikasi edit berarti seharian penuh mengeklik. Di Python, ini cukup sebuah loop, dan keputusan sebenarnya adalah apa yang berjalan di dalam loop itu: model open source di komputer Anda sendiri, atau API HTTP.

Panduan ini membangun keduanya, dengan skrip lengkap yang bisa langsung Anda jalankan pada sebuah folder hari ini, dan membahas bagian yang membuat proses batch bisa diandalkan: pemilihan model, CPU vs GPU, retry, batas rate, idempotensi, dan melanjutkan proses setelah crash.

Opsi A atau opsi B?

Banyak tim memakai keduanya: model lokal untuk eksperimen dan tool internal, API untuk produksi, saat kualitas yang konsisten dan tidak perlu server GPU lebih penting.

Opsi A: rembg, jalur open source

rembg adalah library Python dan CLI berlisensi MIT yang membungkus beberapa model penghapus background dan menjalankannya dengan ONNX Runtime. Saat tulisan ini dibuat, rilis terbarunya adalah 2.0.86, dan membutuhkan Python 3.11 atau lebih baru, tetapi lebih lama dari 3.14.

Instalasi

Pilih backend yang sesuai dengan hardware Anda. Build CPU bisa berjalan di mana saja:

python -m venv .venv && source .venv/bin/activate
pip install "rembg[cpu]"        # library only
pip install "rembg[cpu,cli]"    # library plus the rembg command

Untuk GPU NVIDIA, instal rembg[gpu] sebagai gantinya. Proyek ini mencatat bahwa opsi ini membutuhkan onnxruntime-gpu serta CUDA dan cuDNN yang versinya cocok, dan menyarankan kembali ke build CPU jika Anda tidak bisa menginstalnya. GPU AMD di Linux memakai rembg[rocm] dengan onnxruntime-rocm.

rembg otomatis memilih execution provider CUDA (atau ROCm) jika ONNX Runtime melaporkannya tersedia, dan memberi peringatan jika kembali ke CPU. Untuk mengecek apa yang terdeteksi oleh ONNX Runtime:

import onnxruntime
print(onnxruntime.get_available_providers())  # look for CUDAExecutionProvider

Pilih model

Model diunduh saat pertama kali dipakai ke ~/.rembg/models/ (atur REMBG_HOME untuk mengubahnya). Beberapa model yang berguna dari daftar proyek ini:

Ada dua hal yang lebih penting daripada kelihatannya. Pertama, model default tidak gratis untuk penggunaan komersial: bobot model punya lisensinya sendiri, terpisah dari lisensi MIT rembg, jadi cek sumber model mana pun yang Anda pakai di produk. Kedua, model yang lebih baru (bria-rmbg, birefnet-*, isnet-general-use) menghasilkan tepi yang lembut dan rapi, sedangkan keluarga u2net yang lebih lama cenderung memberi tepi yang lebih keras dan kasar.

Opsi kualitas tepi

rembg menawarkan tiga cara untuk menangani piksel tepi yang lembut seperti rambut dan bulu:

• Default: cukup untuk objek bertepi tegas seperti produk, mobil, dan logo.
• decontaminate=True (-dc di CLI): menghapus halo berwarna yang ditinggalkan background lama di piksel tepi. Opsi ini hanya mengubah warna, tidak pernah mengubah bentuk mask, nyaris tanpa biaya, dan aman dibiarkan aktif untuk satu batch penuh.
• alpha_matting=True (-a): menghitung ulang tepinya sendiri saat bentuk mask salah, misalnya helai rambut terpotong. Opsi ini jauh lebih lambat dan bisa gagal konvergen; dalam kasus itu rembg kembali ke hasil potongan yang sudah didekontaminasi.

Untuk batch yang berjalan tanpa diawasi, proyek ini menyarankan -dc daripada -a karena lebih cepat dan tidak bisa gagal. Panduan alpha channel menjelaskan mengapa halo muncul.

Cara cepat: CLI

rembg p -m birefnet-general -dc photos/ cutouts/

rembg p memproses satu folder penuh; tambahkan -w untuk memantau folder dan memproses file baru begitu muncul.

Skrip Python

Versi ini memuat model sekali saja, melewati file yang sudah selesai sehingga Anda bisa menghentikan dan menjalankannya lagi, dan tetap jalan saat satu file gagal:

import sys
from pathlib import Path

from rembg import new_session, remove

EXTS = {".jpg", ".jpeg", ".png", ".webp"}


def main(in_dir: str, out_dir: str, model: str = "birefnet-general") -> None:
    src_dir, dst_dir = Path(in_dir), Path(out_dir)
    dst_dir.mkdir(parents=True, exist_ok=True)
    session = new_session(model)  # load the model once, reuse it for every image

    files = sorted(p for p in src_dir.iterdir() if p.suffix.lower() in EXTS)
    for i, src in enumerate(files, 1):
        dst = dst_dir / f"{src.stem}.png"
        if dst.exists():
            continue  # resume where a previous run stopped
        try:
            out = remove(src.read_bytes(), session=session, decontaminate=True)
            dst.write_bytes(out)
            print(f"[{i}/{len(files)}] ok      {src.name}")
        except Exception as e:  # one bad file shouldn't stop the batch
            print(f"[{i}/{len(files)}] failed  {src.name}: {e}")


if __name__ == "__main__":
    main(*sys.argv[1:])

Jalankan dengan python batch_rembg.py photos cutouts birefnet-general. Membuat session sekali itu penting: memuat model jauh lebih lama daripada menjalankannya, dan README rembg menyarankan memakai ulang session untuk performa batch. Hasilnya selalu PNG karena memiliki alpha channel.

Kekurangan rembg

• Jalankan pertama lambat karena model sedang diunduh, dan model besar butuh banyak RAM atau VRAM.
• Throughput CPU terbatas dengan model berkualitas tinggi. Tes dengan 20 gambar yang mewakili sebelum memproses seribu gambar.
• Lisensi dan driver adalah urusan Anda. Kunci versi rembg dan model Anda supaya upgrade di kemudian hari tidak diam-diam mengubah hasil.

Opsi B: API HTTP

Dengan API, pekerjaan berat dilakukan di GPU milik pihak lain, dan skrip Anda sebagian besar hanya perlu menangani jaringan dengan baik. Contoh ini memakai API removebackground.dev karena kontraknya dipublikasikan sebagai OpenAPI 3.1 di /openapi.json; pola yang sama berlaku untuk layanan serupa mana pun.

Kontraknya

• POST https://removebackground.dev/v1/remove dengan key Anda di header x-api-key.
• Kirim gambar sebagai field multipart image_file (JPG, PNG, atau WebP, hingga 25 MB), atau sebagai JSON dengan image_url.
• Field opsional mencakup format (png, jpg, atau webp), bg_color, size (preview, medium, hd, full), dan crop.
• 200 berarti body-nya adalah gambar yang sudah jadi. 202 berarti gambar masih diproses setelah sekitar 55 detik: body-nya berupa JSON dengan id job, lalu Anda melakukan polling ke GET /v1/jobs/{id}/result, yang menjawab 409 not_ready dengan Retry-After sampai gambarnya siap. Jangan pernah menyimpan body 202 sebagai gambar.
• Maksimal 60 request pemrosesan per menit per akun; lebih dari itu Anda mendapat 429 rate_limited dengan Retry-After.
• Header Idempotency-Key membuat retry aman: key yang sama dengan request yang sama mengembalikan job awal, bukan menagih lagi. Key yang sama dengan request berbeda dijawab 409 idempotency_key_reused.
• Hasil dihapus setelah 48 jam, jadi simpan begitu Anda menerimanya.

Aturan retry supaya Anda tidak membayar dua kali

Kuncinya adalah membuat idempotency key yang deterministik: hash dari byte gambar ditambah opsinya. Jika skrip crash dan Anda menjalankannya lagi, setiap pengiriman ulang membawa key yang sama, jadi tidak ada yang diproses atau ditagih dua kali.

Skrip Python

import hashlib
import mimetypes
import os
import sys
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path

import requests

API = os.environ.get("REMOVEBG_API", "https://removebackground.dev")
KEY = os.environ["REMOVEBG_API_KEY"]  # keep the key out of your code
OPTIONS = {"format": "png", "size": "full"}  # or {"format": "jpg", "bg_color": "ffffff"}
WORKERS = 4  # the API allows 60 processing requests a minute
EXTS = {".jpg", ".jpeg", ".png", ".webp"}
RETRYABLE = {429, 500, 503}


def idempotency_key(data: bytes) -> str:
    # Same image + same options = same key, so a rerun never pays twice.
    h = hashlib.sha256(data)
    h.update(repr(sorted(OPTIONS.items())).encode())
    return h.hexdigest()


def wait(res, default=2.0):
    try:
        return float(res.headers.get("Retry-After", default))
    except ValueError:
        return default


def save(res, dst: Path) -> Path:
    if res.status_code != 200 or not res.headers.get("Content-Type", "").startswith("image/"):
        raise RuntimeError(f"HTTP {res.status_code}: {res.text[:300]}")
    dst.write_bytes(res.content)
    return dst


def process(src: Path, dst: Path) -> Path:
    data = src.read_bytes()
    mime = mimetypes.guess_type(src.name)[0] or "application/octet-stream"
    headers = {"x-api-key": KEY, "Idempotency-Key": idempotency_key(data)}

    for attempt in range(6):
        try:
            res = requests.post(
                f"{API}/v1/remove",
                files={"image_file": (src.name, data, mime)},
                data=OPTIONS,
                headers=headers,
                timeout=(10, 120),
            )
        except (requests.ConnectionError, requests.Timeout):
            time.sleep(2 ** attempt)  # same key: safe to resend
            continue
        if res.status_code in RETRYABLE:
            time.sleep(wait(res, 2 ** attempt))
            continue
        break
    else:
        raise RuntimeError("gave up after retries")

    if res.status_code != 202:
        return save(res, dst)  # 200 is the image; 4xx and 502 raise

    # 202: still processing. Poll the same job; never upload the image again.
    job_id = res.json()["id"]
    deadline = time.monotonic() + 600
    while time.monotonic() < deadline:
        time.sleep(wait(res))
        try:
            res = requests.get(f"{API}/v1/jobs/{job_id}/result", headers=headers, timeout=30)
        except (requests.ConnectionError, requests.Timeout):
            continue  # reading a job is free and safe to repeat
        if res.status_code == 409 and res.json()["error"]["code"] == "not_ready":
            continue
        if res.status_code >= 500:
            continue
        return save(res, dst)
    raise TimeoutError(f"job {job_id} still running; fetch it later")


def main(in_dir: str, out_dir: str) -> None:
    src_dir, dst_dir = Path(in_dir), Path(out_dir)
    dst_dir.mkdir(parents=True, exist_ok=True)
    ext = ".jpg" if OPTIONS.get("format") == "jpg" else "." + OPTIONS.get("format", "png")
    todo = [
        (p, dst_dir / (p.stem + ext))
        for p in sorted(src_dir.iterdir())
        if p.suffix.lower() in EXTS and not (dst_dir / (p.stem + ext)).exists()
    ]
    print(f"{len(todo)} images to process")

    failed = []
    with ThreadPoolExecutor(max_workers=WORKERS) as pool:
        jobs = {pool.submit(process, s, d): s for s, d in todo}
        for fut in as_completed(jobs):
            src = jobs[fut]
            try:
                print("ok    ", src.name, "->", fut.result().name)
            except Exception as e:
                failed.append(src.name)
                print("failed", src.name, e)
    print(f"done: {len(todo) - len(failed)} ok, {len(failed)} failed")


if __name__ == "__main__":
    main(sys.argv[1], sys.argv[2])

Jalankan dengan REMOVEBG_API_KEY=... python batch_api.py photos cutouts. Empat worker adalah awal yang wajar; jika respons yang cepat membuat Anda melewati batas per menit, penanganan 429 akan menunggu lalu mengirim ulang dengan key yang sama. Untuk mengirim URL alih-alih file, kirim JSON:

res = requests.post(
    f"{API}/v1/remove",
    json={"image_url": "https://example.com/shoe.jpg", "format": "png"},
    headers={"x-api-key": KEY, "Idempotency-Key": "shoe-front-v1"},
    timeout=(10, 120),
)

Untuk daftar URL yang panjang, API yang sama punya POST /v1/batch, yang mengantrekan hingga 100 URL gambar sebagai satu job yang bisa Anda polling.

Membuat batch job apa pun lebih andal

• Lewati output yang sudah selesai supaya saat dijalankan ulang, proses berlanjut, bukan mulai dari awal. Kedua skrip melakukan ini.
• Waspadai nama file yang bentrok. shoe.jpg dan shoe.png di folder yang sama sama-sama menjadi shoe.png; ganti nama input atau sertakan ekstensi asli di nama output.
• Catat kegagalan ke file lalu jalankan ulang hanya yang gagal.
• Cek sampel secara acak di zoom 100% pada background gelap dan terang sebelum memproses semuanya.
• Jangan ubah file asli. Tulis hasilnya ke folder output terpisah.
• Pilih format output sesuai tujuan. PNG atau WebP untuk transparansi, JPG dengan background putih untuk marketplace. Lihat PNG vs JPEG vs WebP.