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 GPUs کے لیے اس کے بجائے rembg[gpu] انسٹال کریں۔ پروجیکٹ بتاتا ہے کہ اس کے لیے onnxruntime-gpu اور مطابقت رکھنے والے CUDA اور cuDNN چاہئیں، اور تجویز کرتا ہے کہ اگر آپ انہیں انسٹال نہ کر سکیں تو CPU بلڈ پر واپس جائیں۔ Linux پر AMD GPUs، onnxruntime-rocm کے ساتھ rembg[rocm] استعمال کرتے ہیں۔

جب ONNX Runtime، CUDA (یا ROCm) execution provider کو دستیاب بتاتا ہے تو 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): جب ماسک کی شکل غلط ہو، مثلاً لٹیں کٹ گئی ہوں، تو کنارے کا دوبارہ اندازہ لگاتا ہے۔ یہ بہت سست ہے اور converge ہونے میں ناکام ہو سکتا ہے، اس صورت میں 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 کے ساتھ بھاری کام کسی اور کے GPUs پر ہوتا ہے، اور آپ کی اسکرپٹ زیادہ تر نیٹ ورک کو ٹھیک سے سنبھالنے کے بارے میں ہے۔ مثال removebackground.dev API استعمال کرتی ہے کیونکہ اس کا کنٹریکٹ /openapi.json پر OpenAPI 3.1 کی صورت میں شائع شدہ ہے؛ یہی پیٹرنز کسی بھی ملتی جلتی سروس پر لاگو ہوتے ہیں۔

کنٹریکٹ

• x-api-key ہیڈر میں اپنی کی کے ساتھ POST https://removebackground.dev/v1/remove۔
• تصویر کو multipart فیلڈ 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 کی کو متعین (deterministic) بنائیں: تصویر کے بائٹس اور آپشنز کا ہیش۔ اگر اسکرپٹ کریش ہو اور آپ اسے دوبارہ چلائیں تو ہر دوبارہ بھیجی گئی ریکویسٹ میں وہی کی ہوتی ہے، اس لیے کچھ بھی دو بار پروسیس یا چارج نہیں ہوتا۔

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 ہینڈلنگ انتظار کر کے اسی کی کے ساتھ دوبارہ بھیجتی ہے۔ فائلوں کے بجائے URLs بھیجنے کے لیے 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),
)

URLs کی لمبی فہرستوں کے لیے اسی API میں POST /v1/batch ہے، جو 100 تصویری URLs تک کو ایک جاب کے طور پر قطار میں رکھتا ہے جسے آپ پول کرتے ہیں۔

کسی بھی بیچ جاب کو مضبوط بنانا

• مکمل آؤٹ پٹس چھوڑ دیں تاکہ دوبارہ چلانے پر نئے سرے سے شروع کرنے کے بجائے وہیں سے آگے بڑھے۔ دونوں اسکرپٹس یہ کرتی ہیں۔
• ناموں کے ٹکراؤ پر نظر رکھیں۔ ایک ہی فولڈر میں shoe.jpg اور shoe.png دونوں shoe.png بن جاتے ہیں؛ ان پٹس کا نام بدلیں یا آؤٹ پٹ نام میں اصل ایکسٹینشن شامل کریں۔
• ناکام فائلوں کو ایک فائل میں لاگ کریں اور صرف انہیں دوبارہ چلائیں۔
• سب کچھ پروسیس کرنے سے پہلے ایک نمونے کو گہرے اور ہلکے بیک گراؤنڈز پر 100% زوم پر چیک کریں۔
• اصل فائلوں کو نہ چھیڑیں۔ الگ آؤٹ پٹ فولڈر میں لکھیں۔
• منزل کے مطابق آؤٹ پٹ فارمیٹ چنیں۔ ٹرانسپیرنسی کے لیے PNG یا WebP، مارکیٹ پلیسز کے لیے سفید پر JPG۔ دیکھیں PNG بمقابلہ JPEG بمقابلہ WebP۔