ICLight

Clore.ai GPUs पर IC-Light के साथ AI-समर्थित इमेज री-लाइटिंग

किसी भी छवि को AI-संचालित प्रकाश नियंत्रण के साथ पुनःप्रकाशित करें।

सभी उदाहरणों को GPU सर्वरों पर चलाया जा सकता है जिन्हें के माध्यम से किराए पर लिया जाता है CLORE.AI मार्केटप्लेस.

इस मार्गदर्शिका के सभी उदाहरणों को GPU सर्वरों पर चलाया जा सकता है जिन्हें के माध्यम से किराए पर लिया जाता है CLORE.AI मार्केटप्लेस मार्केटप्लेस।

CLORE.AI पर किराए पर लेना

1. पर जाएँ CLORE.AI मार्केटप्लेस

2. GPU प्रकार, VRAM और कीमत द्वारा फ़िल्टर करें

3. चुनें ऑन-डिमांड (निर्धारित दर) या स्पॉट (बिड कीमत)

4. अपना ऑर्डर कॉन्फ़िगर करें:

   • Docker इमेज चुनें

   • पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)

   • ज़रूरत होने पर पर्यावरण चर जोड़ें

   • स्टार्टअप कमांड दर्ज करें

5. भुगतान चुनें: CLORE, BTC, या USDT/USDC

6. ऑर्डर बनाएँ और डिप्लॉयमेंट की प्रतीक्षा करें

अपने सर्वर तक पहुँचें

• कनेक्शन विवरण खोजें मेरे ऑर्डर्स

• वेब इंटरफेस: HTTP पोर्ट URL का उपयोग करें

• SSH: ssh -p <port> root@<proxy-address>

IC-Light क्या है?

lllyasviel का IC-Light निम्न कार्य सक्षम करता है:

• पाठ वर्णनों के साथ छवियों का पुनःप्रकाश (Relight)

• प्रकाश की दिशा और रंग बदलें

• छायाएँ जोड़ें या हटाएँ

• स्टूडियो लाइटिंग प्रभाव बनाएं

• फोरग्राउंड/बैकग्राउंड का पुनःप्रकाश

संसाधन

• GitHub: lllyasviel/IC-Light

• HuggingFace: lllyasviel/IC-Light

• डेमो: HuggingFace Space

• पेपर: ControlNet आर्किटेक्चर पर आधारित

अनुशंसित हार्डवेयर

घटक	न्यूनतम	अनुशंसित	सर्वोत्तम
GPU	RTX 3060 12GB	RTX 4080 16GB	RTX 4090 24GB
VRAM	8GB	12GB	16GB
CPU	4 कोर	8 कोर	16 कोर
RAM	16GB	32GB	64GB
स्टोरेज	30GB SSD	50GB NVMe	100GB NVMe
इंटरनेट	100 Mbps	500 Mbps	1 Gbps

CLORE.AI पर त्वरित डिप्लॉय

Docker इमेज:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

पोर्ट्स:

22/tcp
7860/http

कमांड:

cd /workspace && \
git clone https://github.com/lllyasviel/IC-Light.git && \
cd IC-Light && \
pip install -r requirements.txt && \
python gradio_demo.py

अपनी सेवा तक पहुँच

डिप्लॉयमेंट के बाद, अपना खोजें http_pub URL में मेरे ऑर्डर्स:

1. पर जाएँ मेरे ऑर्डर्स पृष्ठ

2. अपने ऑर्डर पर क्लिक करें

3. खोजें http_pub URL (उदा., abc123.clorecloud.net)

उपयोग करें https://YOUR_HTTP_PUB_URL के बजाय localhost नीचे दिए गए उदाहरणों में।

स्थापना

git clone https://github.com/lllyasviel/IC-Light.git
cd IC-Light
pip install -r requirements.txt

# मॉडल पहले रन पर स्वचालित रूप से डाउनलोड हो जाते हैं

आप क्या बना सकते हैं

उत्पाद फोटोग्राफी

• ई-कॉमर्स के लिए परिपूर्ण प्रकाश

• सुसंगत कैटलॉग छवियाँ

• स्टूडियो के बिना स्टूडियो-गुणवत्ता परिणाम

पोर्ट्रेट सुधार

• फोटो में खराब प्रकाश सुधारें

• नाटकीय लाइटिंग प्रभाव जोड़ें

• पेशेवर हेडशॉट बनाएं

रचनात्मक प्रोजेक्ट

• मूड रूपांतरण

• दिन से रात में परिवर्तन

• कलात्मक लाइटिंग प्रभाव

वीडियो प्रोडक्शन

• दृश्यों के बीच लाइटिंग मिलाएं

• VFX-तैयार फुटेज बनाएं

• लोकेशन पर लाइटिंग समस्याओं को ठीक करें

मार्केटिंग सामग्री

• हीरो इमेज निर्माण

• सुसंगत ब्रांड छवियाँ

• त्वरित फोटो रिटचिंग

मूल उपयोग

फोरग्राउंड रीलाइटिंग (FC मोड)

बैकग्राउंड अखड़ा रहने पर सब्जेक्ट को पुनःप्रकाशित करें:

import torch
from PIL import Image
from diffusers import StableDiffusionPipeline
from ic_light import ICLightFC

# मॉडल लोड करें
model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

# छवि लोड करें
image = Image.open("portrait.jpg")

# टेक्स्ट प्रॉम्प्ट के साथ पुनःप्रकाशित करें
result = model.relight(
    image=image,
    prompt="golden hour sunlight from the left",
    num_inference_steps=25
)

result.save("relit_portrait.jpg")

बैकग्राउंड कंडीशन्ड (FBC मोड)

नए बैकग्राउंड से मेल खाने के लिए फोरग्राउंड रीलाइट करें:

from ic_light import ICLightFBC
from PIL import Image

model = ICLightFBC.from_pretrained("lllyasviel/IC-Light-FBC")
model.to("cuda")

# फोरग्राउंड और नया बैकग्राउंड लोड करें
foreground = Image.open("person.png")  # पारदर्शी पृष्ठभूमि के साथ
background = Image.open("sunset_scene.jpg")

# बैकग्राउंड से मेल करने के लिए रीलाइट करें
result = model.relight(
    foreground=foreground,
    background=background,
    prompt="warm sunset lighting",
    num_inference_steps=25
)

result.save("composited.jpg")

लाइटिंग प्रॉम्प्ट

दिशा-आधारित लाइटिंग

prompts = [
    "bright light from the left side",
    "soft light from above",
    "dramatic backlight from behind",
    "rim lighting from the right",
    "front facing diffused light",
    "low angle light from below"
]

रंग-आधारित लाइटिंग

prompts = [
    "warm golden sunlight",
    "cool blue twilight",
    "neon pink light",
    "green ambient light",
    "orange sunset glow",
    "white studio lighting"
]

पर्यावरण-आधारित लाइटिंग

prompts = [
    "outdoor daylight, bright sun",
    "indoor window light, soft shadows",
    "night city lights, neon reflections",
    "candlelight, warm flickering",
    "cloudy day, diffused lighting",
    "studio softbox, professional"
]

बैच प्रोसेसिंग

import os
from PIL import Image
from ic_light import ICLightFC

model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

input_dir = "./images"
output_dir = "./relit"
os.makedirs(output_dir, exist_ok=True)

lighting_prompt = "professional studio lighting, soft shadows"

for filename in os.listdir(input_dir):
    if not filename.endswith(('.jpg', '.png')):
        continue

    image = Image.open(os.path.join(input_dir, filename))

    result = model.relight(
        image=image,
        prompt=lighting_prompt,
        num_inference_steps=25
    )

    result.save(os.path.join(output_dir, f"relit_{filename}"))
    print(f"Processed: {filename}")

कई लाइटिंग विविधताएँ

from ic_light import ICLightFC
from PIL import Image
import os

model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

image = Image.open("product.jpg")

lighting_variations = {
    "daylight": "bright natural daylight, clean white background",
    "dramatic": "dramatic side lighting, dark shadows",
    "warm": "warm golden hour, soft orange glow",
    "cool": "cool blue lighting, modern aesthetic",
    "studio": "professional studio softbox, even lighting"
}

os.makedirs("./variations", exist_ok=True)

for name, prompt in lighting_variations.items():
    result = model.relight(
        image=image,
        prompt=prompt,
        num_inference_steps=25
    )
    result.save(f"./variations/{name}.jpg")
    print(f"Generated: {name}")

Gradio इंटरफ़ेस

import gradio as gr
from PIL import Image
from ic_light import ICLightFC

model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

def relight_image(image, prompt, steps, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    result = model.relight(
        image=image,
        prompt=prompt,
        num_inference_steps=steps,
        generator=generator
    )

    return result

demo = gr.Interface(
    fn=relight_image,
    inputs=[
        gr.Image(type="pil", label="इनपुट इमेज"),
        gr.Textbox(
            label="लाइटिंग प्रॉम्प्ट",
            value="professional studio lighting",
            placeholder="वांछित लाइटिंग का वर्णन करें..."
        ),
        gr.Slider(10, 50, value=25, step=5, label="Steps"),
        gr.Number(value=-1, label="Seed (-1 for random)")
    ],
    outputs=gr.Image(label="Relit Image"),
    title="IC-Light - AI Image Relighting",
    description="किसी भी छवि की लाइटिंग को टेक्स्ट वर्णनों से बदलें। CLORE.AI GPU सर्वरों पर चल रहा है।",
    examples=[
        ["example.jpg", "golden hour sunlight from the left", 25, -1],
        ["example.jpg", "dramatic rim lighting, dark background", 25, -1],
        ["example.jpg", "soft window light, gentle shadows", 25, -1]
    ]
)

demo.launch(server_name="0.0.0.0", server_port=7860)

ComfyUI एकीकरण

IC-Light ComfyUI नोड्स के रूप में उपलब्ध है:

cd ComfyUI/custom_nodes
git clone https://github.com/kijai/ComfyUI-IC-Light.git

ComfyUI वर्कफ़्लो

1. अपनी छवि लोड करें

2. IC-Light Loader नोड जोड़ें

3. IC-Light Apply नोड से कनेक्ट करें

4. लाइटिंग प्रॉम्प्ट सेट करें

5. KSampler से कनेक्ट करें

6. Save Image पर आउटपुट करें

बैकग्राउंड रिमूवल के साथ

from ic_light import ICLightFBC
from rembg import remove
from PIL import Image

# पहले बैकग्राउंड हटाएँ
original = Image.open("photo.jpg")
foreground = remove(original)

# नया बैकग्राउंड लोड करें
background = Image.open("studio_bg.jpg")

# मेल करने के लिए रीलाइट करें
model = ICLightFBC.from_pretrained("lllyasviel/IC-Light-FBC")
model.to("cuda")

result = model.relight(
    foreground=foreground,
    background=background,
    prompt="studio lighting matching background",
    num_inference_steps=25
)

result.save("composited.jpg")

प्रदर्शन

मोड	रिज़ॉल्यूशन	GPU	स्पीड
FC (फोरग्राउंड)	512x512	RTX 3090	3s
FC (फोरग्राउंड)	512x512	RTX 4090	2s
FBC (कम्पोजिट)	512x512	RTX 4090	3s
FC (फोरग्राउंड)	1024x1024	A100	4s

मॉडल वेरिएंट

मॉडल	विवरण	उपयोग का मामला
IC-Light-FC	फोरग्राउंड सुसंगत	एकल छवि रीलाइटिंग
IC-Light-FBC	फोरग्राउंड-बैकग्राउंड सुसंगत	बैकग्राउंड के साथ कम्पोज़िटिंग

सामान्य समस्याएँ और समाधान

लाइटिंग बदलती नहीं है

समस्या: आउटपुट इनपुट जैसा ही दिखता है

समाधान:

• अधिक वर्णनात्मक लाइटिंग प्रॉम्प्ट का उपयोग करें

• इनफेरेंस स्टेप्स को 30-40 तक बढ़ाएँ

• विभिन्न सीड मान आज़माएँ

• प्रॉम्प्ट में अधिक मजबूत कंट्रास्ट का उपयोग करें (उदा., "dramatic" बनाम "soft")

# अधिक वर्णनात्मक प्रॉम्प्ट
result = model.relight(
    image=image,
    prompt="extremely bright dramatic spotlight from upper left, dark shadows on right side",
    num_inference_steps=35
)

चेहरे/विवरणों पर आर्टिफ़ैक्ट्स

समस्या: चेहरा या विवरण विकृत दिखते हैं

समाधान:

• स्ट्रेंथ/गाइडेंस स्केल कम करें

• अधिक इनफेरेंस स्टेप्स का उपयोग करें

• लाइटिंग परिवर्तन सूक्ष्म रखें

• फेस रिस्टोरेशन के साथ पोस्ट-प्रोसेस करें

रंग शिफ्ट समस्याएँ

समस्या: अनचाहे रंग परिवर्तन

समाधान:

• प्रॉम्प्ट में रंग के बारे में स्पष्ट रहें

• प्रॉम्प्ट में "preserve original colors" जोड़ें

• रंग-तटस्थ लाइटिंग विवरणों का उपयोग करें

• पोस्ट-प्रोसेस रंग सुधार करें

बैकग्राउंड परिवर्तन

समस्या: केवल फोरग्राउंड होना चाहिए पर बैकग्राउंड बदल जाता है

समाधान:

• FC मोड (फोरग्राउंड सुसंगत) का उपयोग करें

• बैकग्राउंड रिमूवल के साथ प्री-प्रोसेस करें

• विषय को अलग करने के लिए मास्क का उपयोग करें

असंगत परिणाम

समस्या: एक ही प्रॉम्प्ट बहुत अलग परिणाम देता है

समाधान:

• पुनरुत्पादन के लिए फिक्स्ड सीड सेट करें

• स्थिरता के लिए इनफेरेंस स्टेप्स बढ़ाएँ

• सरल, अधिक प्रत्यक्ष प्रॉम्प्ट का उपयोग करें

# फिक्स्ड सीड के साथ सुसंगत परिणाम
result = model.relight(
    image=image,
    prompt=prompt,
    num_inference_steps=30,
    generator=torch.Generator("cuda").manual_seed(42)
)

समस्या निवारण

रीलाइटिंग अस्वाभाविक दिखती है

• दृश्य के साथ लाइटिंग की दिशा मिलाएँ

• उपयुक्त लाइट इंटेंसिटी का उपयोग करें

• मूल छवि में छायाओं पर विचार करें

बैकग्राउंड प्रभावित हुआ

• फोरग्राउंड मास्क का सही उपयोग करें

• पहले विषय को बैकग्राउंड से अलग करें

• लाइट फॉलऑफ सेटिंग समायोजित करें

आउटपुट बहुत अँधेरा/उज्जवल

• लाइट इंटेंसिटी मान समायोजित करें

• यदि उपलब्ध हो तो HDR आउटपुट का उपयोग करें

• कर्व्स के साथ पोस्ट-प्रोसेस करें

मॉडल लोड नहीं हो रहा

• सभी आवश्यक चेकपॉइंट डाउनलोड करें

• फ़ाइल अखंडता जांचें

• CUDA संगतता सत्यापित करें

लागत अनुमान

सामान्य CLORE.AI मार्केटप्लेस दरें (2024 के अनुसार):

GPU	घंटा दर	दैनिक दर	4-घंटे सत्र
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

कीमतें प्रदाता और माँग के अनुसार बदलती हैं। वर्तमान दरों के लिए जाँच करें CLORE.AI मार्केटप्लेस ।

पैसे बचाएँ:

• उपयोग करें स्पॉट लचीले वर्कलोड के लिए मार्केट (अकसर 30-50% सस्ता)

• के साथ भुगतान करें CLORE टोकन

• विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

अगले कदम

• TripoSR - रीलिट छवियों को 3D में कनवर्ट करें

• Stable Diffusion - रीलाइट करने के लिए छवियाँ जनरेट करें

• ComfyUI - उन्नत वर्कफ़्लो एकीकरण

• Fooocus - सरल छवि जनरेशन