Python થી બેચમાં ઇમેજ બેકગ્રાઉન્ડ રિમૂવ: rembg વિરુદ્ધ API

તમારી પાસે થોડાક સો પ્રોડક્ટ ફોટા, હેડશોટ કે લિસ્ટિંગ ઇમેજનું ફોલ્ડર છે, અને દરેકનું બેકગ્રાઉન્ડ રિમૂવ કરવાનું છે. એડિટરમાં હાથે કરો તો આખો દિવસ ક્લિક કરવામાં જાય. Python માં તે એક લૂપ છે, અને ખરો નિર્ણય એ છે કે લૂપની અંદર શું ચાલે: તમારા પોતાના મશીન પર ઓપન-સોર્સ મોડેલ, કે HTTP API.

આ ગાઇડ બંને બનાવે છે, એવી પૂરી સ્ક્રિપ્ટ સાથે જે તમે આજે જ ફોલ્ડર પર ચલાવી શકો, અને બેચ જોબને વિશ્વસનીય બનાવતા ભાગ આવરે છે: મોડેલની પસંદગી, CPU વિરુદ્ધ GPU, રિટ્રાય, રેટ લિમિટ, idempotency અને ક્રેશ પછી ફરી શરૂ કરવું.

વિકલ્પ A કે વિકલ્પ B?

ઘણી ટીમ બંને વાપરે છે: પ્રયોગ અને આંતરિક ટૂલ માટે લોકલ મોડેલ, પ્રોડક્શન માટે API, જ્યાં અનુમાન કરી શકાય તેવી ક્વોલિટી અને GPU સર્વર ન રાખવાં વધુ મહત્વનાં છે.

વિકલ્પ A: rembg, ઓપન-સોર્સ રસ્તો

rembg MIT-લાઇસન્સવાળી Python લાઇબ્રેરી અને CLI છે, જે ઘણાં બેકગ્રાઉન્ડ રિમૂવલ મોડેલને સાથે રાખીને ONNX Runtime થી ચલાવે છે. લખતી વખતે હાલની રિલીઝ 2.0.86 છે, અને તેને Python 3.11 કે પછીનું અને 3.14 પહેલાંનું વર્ઝન જોઈએ.

ઇન્સ્ટોલ

તમારા હાર્ડવેર સાથે મેળ ખાતું બેકએન્ડ પસંદ કરો. CPU બિલ્ડ બધે ચાલે છે:

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

NVIDIA GPU માટે તેના બદલે rembg[gpu] ઇન્સ્ટોલ કરો. પ્રોજેક્ટ નોંધે છે કે તેના માટે onnxruntime-gpu અને મેળ ખાતાં CUDA તથા cuDNN જોઈએ, અને તે ઇન્સ્ટોલ ન થઈ શકે તો CPU બિલ્ડ પર પાછા જવાનું સૂચવે છે. Linux પર AMD GPU onnxruntime-rocm સાથે rembg[rocm] વાપરે છે.

ONNX Runtime CUDA (કે ROCm) એક્ઝિક્યુશન પ્રોવાઇડરને ઉપલબ્ધ ગણાવે ત્યારે rembg તેને આપમેળે પસંદ કરે છે, અને CPU પર પાછું જાય તો ચેતવણી આપે છે. ONNX Runtime શું જોઈ શકે છે તે તપાસવા:

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

મોડેલ પસંદ કરો

પહેલા ઉપયોગે મોડેલ ~/.rembg/models/ માં ડાઉનલોડ થાય છે (બદલવા REMBG_HOME સેટ કરો). પ્રોજેક્ટની યાદીમાંથી કેટલાંક ઉપયોગી મોડેલ:

બે મુદ્દા દેખાય તેના કરતાં વધુ મહત્વના છે. પહેલો, ડિફોલ્ટ મોડેલ વ્યાવસાયિક ઉપયોગ માટે ફ્રી નથી: મોડેલનાં વેઇટ પોતાનાં લાઇસન્સ ધરાવે છે, rembg ના MIT લાઇસન્સથી અલગ, તેથી તમે જે મોડેલ સાથે કામ ચલાવો તેનો સોર્સ તપાસો. બીજો, નવાં મોડેલ (bria-rmbg, birefnet-*, isnet-general-use) નરમ, સુઘડ આકારની કિનારી આપે છે, જ્યારે જૂનું u2net કુટુંબ વધુ સખત, ચોરસ જેવી કિનારી આપે છે.

કિનારીની ક્વોલિટીના વિકલ્પ

વાળ અને રુવાંટી જેવા નરમ કિનારીના પિક્સેલ સંભાળવા rembg ત્રણ રીત આપે છે:

• ડિફોલ્ટ: પ્રોડક્ટ, કાર અને લોગો જેવા સખત કિનારીવાળા સબ્જેક્ટ માટે બરાબર.
• decontaminate=True (CLI પર -dc): જૂનું બેકગ્રાઉન્ડ કિનારીના પિક્સેલમાં જે રંગીન હેલો છોડે છે તે દૂર કરે છે. તે માત્ર રંગ બદલે છે, માસ્કનો આકાર ક્યારેય નહીં, ખર્ચ ખૂબ ઓછો છે, અને આખી બેચ માટે ચાલુ રાખવું સુરક્ષિત છે.
• alpha_matting=True (-a): માસ્કનો આકાર ખોટો હોય, ઉદાહરણ તરીકે વાળ કપાઈ ગયા હોય, ત્યારે કિનારી જ ફરી ગણે છે. તે ઘણું ધીમું છે અને ક્યારેક કન્વર્જ ન પણ થાય, એ કિસ્સામાં rembg ડિકન્ટેમિનેટ કરેલા કટઆઉટ પર પાછું જાય છે.

દેખરેખ વગરની બેચ માટે પ્રોજેક્ટ -a ને બદલે -dc ની ભલામણ કરે છે કારણ કે તે ઝડપી છે અને નિષ્ફળ ન જઈ શકે. હેલો કેમ થાય છે તે આલ્ફા ચેનલ ગાઇડ સમજાવે છે.

ઝડપી રીત: CLI

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

rembg p આખું ફોલ્ડર પ્રોસેસ કરે છે; ફોલ્ડર પર નજર રાખીને નવી ફાઇલ આવે તેમ પ્રોસેસ કરવા -w ઉમેરો.

Python સ્ક્રિપ્ટ

આ વર્ઝન મોડેલ એક વાર લોડ કરે છે, પહેલેથી પૂરી થયેલી ફાઇલ છોડી દે છે જેથી તમે રોકીને ફરી શરૂ કરી શકો, અને એક ફાઇલ નિષ્ફળ જાય તો પણ ચાલુ રહે છે:

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:])

python batch_rembg.py photos cutouts birefnet-general થી ચલાવો. સેશન એક વાર બનાવવું મહત્વનું છે: મોડેલ લોડ કરવામાં તેને ચલાવવા કરતાં ઘણો વધુ સમય લાગે છે, અને rembg README બેચ પર્ફોર્મન્સ માટે સેશન ફરી વાપરવાની ભલામણ કરે છે. આઉટપુટ હંમેશાં PNG હોય છે કારણ કે પરિણામમાં આલ્ફા ચેનલ હોય છે.

rembg ક્યાં ઓછું પડે છે

• મોડેલ ડાઉનલોડ થતું હોય ત્યારે પહેલો રન ધીમો હોય છે, અને મોટાં મોડેલને ઘણી RAM કે VRAM જોઈએ.
• ઊંચી ક્વોલિટીનાં મોડેલ સાથે CPU થ્રુપુટ સાધારણ છે. હજાર ઇમેજ પર જતાં પહેલાં 20 પ્રતિનિધિ ઇમેજ પર ટેસ્ટ કરો.
• લાઇસન્સ અને ડ્રાઇવર તમારી જવાબદારી છે. rembg અને મોડેલનાં વર્ઝન પિન કરો જેથી પછીનું અપગ્રેડ ચૂપચાપ પરિણામ ન બદલે.

વિકલ્પ B: HTTP API

API સાથે ભારે કામ બીજા કોઈના GPU પર થાય છે, અને તમારી સ્ક્રિપ્ટનું કામ મુખ્યત્વે નેટવર્ક સારી રીતે સંભાળવાનું છે. ઉદાહરણમાં removebackground.dev API વપરાય છે કારણ કે તેનો કોન્ટ્રાક્ટ /openapi.json પર OpenAPI 3.1 તરીકે પ્રકાશિત છે; આ જ પેટર્ન આવી કોઈ પણ સર્વિસને લાગુ પડે છે.

કોન્ટ્રાક્ટ

• x-api-key હેડરમાં તમારી કી સાથે POST https://removebackground.dev/v1/remove.
• ઇમેજ મલ્ટિપાર્ટ ફીલ્ડ image_file તરીકે મોકલો (JPG, PNG કે WebP, 25 MB સુધી), કે image_url સાથે JSON તરીકે.
• વૈકલ્પિક ફીલ્ડમાં format (png, jpg કે webp), bg_color, size (preview, medium, hd, full) અને crop છે.
• 200 એટલે બોડી તૈયાર ઇમેજ છે. 202 એટલે આશરે 55 સેકન્ડ પછી પણ પ્રોસેસ ચાલુ છે: બોડી જોબ id સાથેનું JSON છે, અને તમે GET /v1/jobs/{id}/result પોલ કરો છો, જે ઇમેજ તૈયાર ન થાય ત્યાં સુધી Retry-After સાથે 409 not_ready જવાબ આપે છે. ક્યારેય 202 બોડીને ઇમેજ તરીકે સેવ ન કરો.
• એકાઉન્ટ દીઠ મિનિટે 60 સુધી પ્રોસેસિંગ રિક્વેસ્ટ; તેનાથી વધુ થાય તો Retry-After સાથે 429 rate_limited મળે છે.
• Idempotency-Key હેડર રિટ્રાયને સુરક્ષિત બનાવે છે: એ જ રિક્વેસ્ટ સાથે એ જ કી ફરી ચાર્જ કરવાને બદલે મૂળ જોબ પાછી આપે છે. અલગ રિક્વેસ્ટ સાથે એ જ કી 409 idempotency_key_reused જવાબ આપે છે.
• પરિણામ 48 કલાક પછી ડિલીટ થાય છે, તેથી મળે ત્યારે જ સેવ કરો.

બે વાર ચૂકવણીથી બચાવતા રિટ્રાય નિયમો

યુક્તિ એ છે કે idempotency કી નિશ્ચિત બનાવો: ઇમેજના બાઇટ અને વિકલ્પોનો હેશ. સ્ક્રિપ્ટ ક્રેશ થાય અને તમે ફરી ચલાવો, તો દરેક ફરી મોકલેલી રિક્વેસ્ટ એ જ કી લઈ જાય છે, તેથી કંઈ પણ બે વાર પ્રોસેસ કે ચાર્જ થતું નથી.

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])

REMOVEBG_API_KEY=... python batch_api.py photos cutouts થી ચલાવો. ચાર વર્કર સાધારણ શરૂઆત છે; ઝડપી રિસ્પોન્સથી મિનિટની મર્યાદા પાર થાય તો 429 હેન્ડલિંગ રાહ જોઈને એ જ કી સાથે ફરી મોકલે છે. ફાઇલને બદલે URL મોકલવા 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),
)

URL ની લાંબી યાદી માટે એ જ API માં POST /v1/batch છે, જે 100 સુધી ઇમેજ URL ને એક જોબ તરીકે કતારમાં મૂકે છે, જેને તમે પોલ કરો છો.

કોઈ પણ બેચ જોબને મજબૂત બનાવવી

• પૂરાં થયેલાં આઉટપુટ છોડી દો જેથી ફરી ચલાવો ત્યારે શરૂઆતથી નહીં, જ્યાં અટક્યું હતું ત્યાંથી ચાલે. બંને સ્ક્રિપ્ટ આમ કરે છે.
• નામની ટક્કર પર ધ્યાન રાખો. એક જ ફોલ્ડરમાં shoe.jpg અને shoe.png બંને shoe.png બની જાય છે; ઇનપુટનાં નામ બદલો કે આઉટપુટ નામમાં મૂળ એક્સટેન્શન રાખો.
• નિષ્ફળતા ફાઇલમાં લોગ કરો અને માત્ર એ જ ફરી ચલાવો.
• બધું પ્રોસેસ કરતાં પહેલાં ઘેરા અને આછા બેકગ્રાઉન્ડ પર 100% ઝૂમે થોડા નમૂના તપાસો.
• મૂળ ફાઇલ જેમની તેમ રાખો. અલગ આઉટપુટ ફોલ્ડરમાં લખો.
• મંજિલ મુજબ આઉટપુટ ફોર્મેટ પસંદ કરો. ટ્રાન્સપરન્સી માટે PNG કે WebP, માર્કેટપ્લેસ માટે સફેદ પર JPG. જુઓ PNG વિરુદ્ધ JPEG વિરુદ્ધ WebP.