rembg और U²-Net के साथ Background Removal: एक संपूर्ण, व्यावहारिक गाइड

किसी छवि से बैकग्राउंड हटाने का मतलब हुआ करता था एक एडिटर खोलना, विषय के चारों ओर ट्रेस करना और किनारों को हाथ से साफ़ करना। 7 अगस्त 2026 तक, आप इसे एक लाइन के कोड में कर सकते हैं — ऑफ़लाइन, मुफ़्त में — एक ओपन-सोर्स टूल की बदौलत जिसका नाम है rembg और वह डीप-लर्निंग मॉडल जिस पर यह काम करता है, U²-Net। यह गाइड बताती है कि ये दोनों क्या हैं, वे एक साथ कैसे फ़िट होते हैं, और आपको कॉपी-पेस्ट करने वाले उदाहरण देती है जिन्हें आप आज ही रन कर सकते हैं।

अब क्यों? बैकग्राउंड रिमूवल चुपचाप हर जगह है: सफ़ेद रंग पर ई-कॉमर्स प्रोडक्ट शॉट्स, प्रोफ़ाइल अवतार, थंबनेल, स्टिकर पैक, ID फ़ोटो, अन्य मॉडलों के लिए डेटासेट की तैयारी, और ऐप आइकन। क्लाउड APIs प्रति छवि शुल्क लेते हैं और आपकी तस्वीरों को किसी तीसरे पक्ष को भेजते हैं। rembg वही काम लोकली (locally) करता है, जो सस्ता, निजी और स्क्रिप्ट करने योग्य है।

समस्या: विषय को बैकग्राउंड से अलग करना

इस कार्य का तकनीकी नाम है salient object detection (SOD): उन पिक्सेल (pixels) को खोजना जो एक छवि में सबसे अधिक दिखाई देने वाली प्रमुख वस्तु बनाते हैं। एक बार जब आपके पास वह प्रति-पिक्सेल "क्या यह विषय है?" मैप आ जाता है, तो बैकग्राउंड रिमूवल बस बाकी सब कुछ पारदर्शी बनाने जैसा है। इसलिए कठिन हिस्सा मिटाना नहीं है — यह एक सटीक मास्क तैयार करना है, खासकर बालों, फर और कांच जैसे मुश्किल किनारों के आसपास।

U²-Net क्या है?

U²-Net (जिसका उच्चारण "U-squared Net" है) salient object detection के लिए 2020 में प्रकाशित एक डीप न्यूरल नेटवर्क है। इसका मुख्य विचार एक नेस्टेड (nested), दो-स्तरीय U-स्ट्रक्चरहै। एक क्लासिक U-Net में एक एनकोडर होता है जो विशेषताओं को सीखते हुए छवि को छोटा करता है, और एक डिकोडर होता है जो इसे वापस पूर्ण-रिज़ॉल्यूशन मास्क में विस्तारित करता है। U²-Net एक छोटा U-आकार का ब्लॉक रखता है — जिसे ReSidual U-block (RSU) कहा जाता है — एक बड़े U-आकार के नेटवर्क के प्रत्येक चरण के अंदर। वह "U के अंदर U" इसे असंभव रूप से भारी हुए बिना बारीक विवरण और बड़े पैमाने के संदर्भ दोनों को कैप्चर करने देता।

आउटपुट एक रंगीन छवि नहीं है। यह एक ग्रेस्केल (grayscale) saliency mapहै: प्रत्येक पिक्सेल को 0 (बैकग्राउंड) से 1 (विषय) तक का मान मिलता है। rembg उस मैप को लेता है, उसका उपयोग alpha channelके रूप में करता है, और आपको एक पारदर्शी PNG सौंपता है।

दो आकार व्यापक रूप से शिप किए जाते हैं:

• u2net — पूर्ण मॉडल, लगभग 176 MB, सर्वोत्तम सामान्य सटीकता।
• u2netp — एक हल्का संस्करण, 5 MB से कम, बहुत तेज़ और छोटा, थोड़ा कम सटीक।

rembg क्या है?

rembg एक ओपन-सोर्स (MIT-लाइसेंस प्राप्त) Python टूल और लाइब्रेरी है जो U²-Net — और कई नए मॉडलों — को एक बेहद सरल इंटरफ़ेस के पीछे रैप करता है। यह मॉडलों को ONNX Runtimeके माध्यम से रन करता है, इसलिए यह साधारण CPU और वैकल्पिक रूप से GPU पर काम करता है। पहले उपयोग पर यह मॉडल वेट्स को एक बार डाउनलोड करता है और उन्हें ~/.u2net/में कैश करता है, फिर उसके बाद पूरी तरह से ऑफ़लाइन रन होता है।

आपको इसका उपयोग करने के तीन तरीके मिलते हैं: एक कमांड-लाइन टूल, एक Python फ़ंक्शन, और एक छोटा HTTP सर्वर।

कदम 1: इंस्टॉल करें

# Library + command-line interface
pip install "rembg[cli]"

# Optional: GPU acceleration (needs a CUDA-capable setup)
pip install "rembg[gpu]"

जब आप पहली बार कोई कमांड रन करते हैं, तो rembg मॉडल को ~/.u2net/ (एक बार, डिफ़ॉल्ट मॉडल के लिए ~176 MB) में लाता है। उसके बाद यह ऑफ़लाइन रहता है।

कदम 2: बैकग्राउंड हटाएँ

इसे आज़माने का सबसे तेज़ तरीका कमांड लाइन है:

# One image: input can be JPG/PNG/WebP, output should be PNG (needs transparency)
rembg i photo.jpg photo-nobg.png

# A whole folder at once
rembg p ./input-images ./output-images

# Run it as a local HTTP service (great for apps)
rembg s
# then POST an image to http://localhost:7000/api/remove

Python API भी उतना ही छोटा है। PIL इमेज के साथ काम करना सबसे साफ़ तरीका है:

from rembg import remove
from PIL import Image

with Image.open("photo.jpg") as img:
    result = remove(img)          # returns an RGBA image with the background cut out
    result.save("photo-nobg.png") # PNG preserves transparency

यदि आप रॉ बाइट्स (raw bytes) (वेब हैंडलर या पाइपलाइन के लिए) पसंद करते हैं:

from rembg import remove

with open("photo.jpg", "rb") as src, open("photo-nobg.png", "wb") as dst:
    dst.write(remove(src.read()))

कदम 3: आगे बढ़ें — मॉडल, साफ़ किनारे, और नए बैकग्राउंड

सही मॉडल चुनें

rembg कई मॉडलों का समर्थन करता है; आप CLI पर -m के साथ या Python में एक session के साथ किसी एक को चुनते हैं। अलग-अलग मॉडल अलग-अलग विषयों के अनुकूल होते हैं:

Model	इसके लिए सर्वोत्तम	नोट्स
u2net	सामान्य उद्देश्य (डिफ़ॉल्ट)	संतुलित सटीकता, ~176 MB
u2netp	गति (Speed) / कम मेमोरी	छोटा (<5 MB), थोड़ा रफ़ (rougher)
u2net_human_seg	लोग / पोर्ट्रेट	मानव आकृतियों के लिए ट्यून किया गया
isnet-general-use	तीखे (Sharper) सामान्य मास्क	अक्सर u2net से ज़्यादा साफ़
silueta	u2net सटीकता, छोटा आकार	~43 MB ड्रॉप-इन
birefnet-general	उच्चतम गुणवत्ता वाले किनारे	बड़ा और धीमा, बालों पर उत्कृष्ट

# CLI: use the human-segmentation model
rembg i -m u2net_human_seg portrait.jpg portrait-nobg.png

# Python: reuse one session across many images (much faster in a batch)
from rembg import remove, new_session
from PIL import Image

session = new_session("isnet-general-use")
for name in ("a.jpg", "b.jpg", "c.jpg"):
    with Image.open(name) as img:
        remove(img, session=session).save(name.replace(".jpg", "-nobg.png"))

alpha matting के साथ बारीक किनारों को साफ़ करें

बाल और मुलायम किनारे वे जगह हैं जहाँ एक रॉ (raw) मास्क कैंची से काटा हुआ लगता है। rembg में इन ट्रांज़िशन (transitions) को नरम करने और सुधारने के लिए अंतर्निहित (built-in) alpha matting है:

from rembg import remove
from PIL import Image

with Image.open("hair.jpg") as img:
    result = remove(
        img,
        alpha_matting=True,
        alpha_matting_foreground_threshold=240,
        alpha_matting_background_threshold=10,
        alpha_matting_erode_size=10,
    )
    result.save("hair-nobg.png")

यह धीमा है, लेकिन पोर्ट्रेट और प्यारे जानवरों (furry animals) पर अंतर नाटकीय (dramatic) है।

बैकग्राउंड हटाने के बजाय उसे बदलें

एक पारदर्शी PNG अक्सर पहला कदम होता है। विषय को एक ठोस रंग (उदाहरण के लिए, एक सफ़ेद ई-कॉमर्स बैकग्राउंड) पर रखने के लिए, इसे कंपोज़िट (composite) करें:

from rembg import remove
from PIL import Image

foreground = remove(Image.open("product.jpg"))          # RGBA subject
background = Image.new("RGBA", foreground.size, (255, 255, 255, 255))
Image.alpha_composite(background, foreground).convert("RGB").save("product-white.jpg")

रंग बदलें, या किसी अन्य फ़ोटो को बैकग्राउंड के रूप में उपयोग करें, और आपके पास कुछ लाइनों में एक पूर्ण कंपोज़िटिंग (compositing) पाइपलाइन है।

एक असली उदाहरण: एक पारदर्शी प्रोफ़ाइल बैज

यहाँ एक एंड-टू-एंड (end-to-end) परिदृश्य है। मान लीजिए कि आप एक पोर्ट्रेट को एक गोल, पारदर्शी "बैज" में बदलना चाहते हैं — व्यक्ति कट आउट, एक वृत्त में फ़्रेम किया हुआ, बाकी सब कुछ आर-पार दिखने वाला, ताकि यह एक तैरते हुए स्टिकर जैसा लगे।

from rembg import remove, new_session
from PIL import Image, ImageDraw

# 1. Cut out the person with the human model + alpha matting for clean hair edges
session = new_session("u2net_human_seg")
with Image.open("me.jpg") as img:
    cut = remove(img, session=session, alpha_matting=True).convert("RGBA")

# 2. Center-crop to a square
side = min(cut.size)
left, top = (cut.width - side) // 2, (cut.height - side) // 2
square = cut.crop((left, top, left + side, top + side))

# 3. Apply a circular mask so only a disc remains
mask = Image.new("L", square.size, 0)
ImageDraw.Draw(mask).ellipse((0, 0, side, side), fill=255)
square.putalpha(mask)

square.save("badge.png")  # transparent circular badge, ready to use

फ़ोटो-आधारित ऐप आइकन और प्रोफ़ाइल बैज के पीछे यही सटीक पैटर्न है: rembg भारी काम (व्यक्ति को ढूँढना) करता है, और PIL की कुछ लाइनें फ़्रेमिंग करती हैं।

यह एंड टू एंड कैसे काम करता है

1. rembg आपकी छवि का आकार बदलता है और इसे ONNX Runtime के माध्यम से U²-Net मॉडल को फ़ीड करता है।
2. U²-Net एक saliency map आउटपुट करता है — एक ग्रेस्केल अनुमान कि कौन से पिक्सेल विषय हैं।
3. rembg उस मैप को मूल आयामों (dimensions) में वापस आकार देता है और इसे alpha channel के रूप में उपयोग करता है।
4. वैकल्पिक रूप से, alpha matting विषय और बैकग्राउंड के बीच की सीमा को निखारता है।
5. आपको एक RGBA इमेज मिलती है जिसका बैकग्राउंड चला गया है।

प्रदर्शन (Performance) और व्यावहारिक सुझाव

• CPU ठीक है कभी-कभार उपयोग के लिए; आकार और मॉडल के आधार पर प्रति छवि लगभग एक सेकंड या कुछ सेकंड की अपेक्षा करें। बैचों (batches) के लिए rembg[gpu] इंस्टॉल करें और एक CUDA सेटअप का उपयोग करें।
• एक session का पुन: उपयोग करें (new_session(...)) कई छवियों (images) में — इसे बनाना धीमा हिस्सा है, इसलिए इसे एक बार करें।
• बड़े इनपुट को डाउनस्केल (Downscale) करें प्रोसेस करने से पहले यदि आपको केवल वेब-आकार के रिज़ल्ट की आवश्यकता है; यह तेज़ है और मास्क आमतौर पर उतना ही अच्छा होता है।
• Cache यहाँ रहता है ~/.u2net/ — अपने Docker इमेज में मॉडल प्री-डाउनलोड (pre-download) करें ताकि प्रोडक्शन रनटाइम पर कभी फ़ेच (fetch) न करे।
• आउटपुट PNG (या WebP) होना चाहिए पारदर्शिता (transparency) बनाए रखने के लिए; JPG पारदर्शी क्षेत्र को काले रंग से भर देगा।

2026 में यह क्यों मायने रखता है

U²-Net जैसे स्थानीय (Local), ओपन-सोर्स मॉडल ने एक ऐसे कार्य को स्क्रिप्ट करने योग्य, निजी, शून्य-लागत वाले चरण में बदल दिया है, जिसके लिए कभी किसी डिज़ाइनर या सशुल्क API की आवश्यकता होती थी। यह बैच पाइपलाइनों (रातोंरात हजारों उत्पाद छवियों), ऑन-डिवाइस ऐप्स जो आपकी तस्वीरें कभी अपलोड नहींচেতন करते हैं, और अवतार और स्टिकर जैसे रचनात्मक ऑटोमेशन को अनलॉक करता है। rembg उस क्षमता का एक अनुकूल (friendly) प्रवेश द्वार है।

निष्कर्ष

rembg आपको एक लाइन में प्रोडक्शन-ग्रेड (production-grade) बैकग्राउंड रिमूवल देता है, और U²-Net वह salient-object मॉडल है जो नीचे असली काम कर रहा है। डिफ़ॉल्ट u2netसे शुरू करें, लोगों के लिए u2net_human_seg पर स्विच करें, जब किनारे मायने रखते हों तो alpha matting का उपयोग करें, और जब आपको कट-आउट से अधिक की आवश्यकता हो तो एक नए बैकग्राउंड पर कंपोज़िट (composite) करें।

गुण (Merits)

• बैकग्राउंड हटाने के लिए एक लाइन; मुफ़्त और ओपन सोर्स (MIT)।
• ऑफ़लाइन और लोकली (locally) चलता है — निजी और सस्ता, कोई प्रति-छवि API शुल्क नहीं।
• विभिन्न विषयों के लिए कई मॉडल, साथ ही बारीक किनारों के लिए alpha matting।
• CLI, Python लाइब्रेरी, या HTTP सर्वर के रूप में काम करता है; CPU या GPU।

दोष (Demerits)

• पहला रन एक बड़ा मॉडल (डिफ़ॉल्ट के लिए ~176 MB) डाउनलोड करता है।
• बहुत बड़ी छवियों या बड़े बैचों की CPU प्रोसेसिंग धीमी हो सकती है।
• बहुत बारीक विवरण (उड़ते बाल, पारदर्शी कांच) के लिए अभी भी alpha matting या BiRefNet जैसे भारी मॉडल की आवश्यकता होती है।
• बिना किसी एक स्पष्ट विषय वाले अव्यवस्थित (cluttered) दृश्यों में सटीकता कम हो जाती है।

सावधानी (Caution)

यह लेख शैक्षिक उद्देश्यों के लिए है। उदाहरण फ़ाइल नामों और पथों (paths) को अपने स्वयं के साथ बदलें, उन पर भरोसा करने से पहले वर्तमान rembg दस्तावेज़ों के विरुद्ध मॉडल नामों को सत्यापित करें, और आपके द्वारा संसाधित (process) की जाने वाली किसी भी छवि के कॉपीराइट और गोपनीयता का सम्मान करें। मॉडल व्यवहार और पैकेज विकल्प संस्करणों (versions) के बीच बदल सकते हैं।

अक्सर पूछे जाने वाले प्रश्न (Frequently asked questions)

• rembg क्या है? — एक ओपन-सोर्स Python टूल और लाइब्रेरी जो डीप-लर्निंग मॉडल, मुख्य रूप से U²-Net, का उपयोग करके छवि बैकग्राउंड हटाती है।
• rembg डिफ़ॉल्ट रूप से किस मॉडल का उपयोग करता है? — u2net, पूर्ण U²-Net salient-object-detection मॉडल का।
• U²-Net क्या है? — नेस्टेड दो-स्तरीय U-स्ट्रक्चर वाला 2020 का न्यूरल नेटवर्क जो यह भविष्यवाणी करता है कि कौन से पिक्सेल सबसे प्रमुख वस्तु के हैं, जो saliency mask के रूप में आउटपुट होता है।
• क्या rembg मुफ़्त और ओपन सोर्स है? — हाँ, यह MIT-लाइसेंस प्राप्त है और उपयोग के लिए मुफ़्त है।
• क्या मुझे GPU की आवश्यकता है? — नहीं। यह ONNX Runtime के माध्यम से CPU पर चलता है; एक GPU केवल बड़े बैचों को तेज़ बनाता है।
• मैं बालों के आसपास साफ़ किनारे कैसे प्राप्त करूँ? — सक्षम (Enable) करें alpha_matting=True, या एक उच्च-गुणवत्ता वाले मॉडल का उपयोग करें जैसे isnet-general-use या birefnet-general.
• लोगों के लिए कौन सा मॉडल सबसे अच्छा है? — u2net_human_seg, जो मानव आकृतियों के लिए ट्यून किया गया है।
• मॉडल कहाँ स्टोर किए जाते हैं? — इसमें: ~/.u2net/, पहले उपयोग पर एक बार डाउनलोड किया जाता है और फिर ऑफ़लाइन उपयोग किया जाता है।

टैग (Tags)

#python #machine-learning #image-processing #rembg #u2net #computer-vision #deep-learning #background-removal #onnx #open-source