IP-Adapter

IP-Adapter के साथ Stable Diffusion के लिए प्रॉम्प्ट के रूप में इमेजेस का उपयोग करें

स्थिर डिफ्यूजन जनरेशन के लिए संकेतों के रूप में छवियों का उपयोग करें।

सभी उदाहरण 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>

IP-एडाप्टर क्या है?

IP-एडाप्टर छवि संकेतिंग सक्षम करता है:

• उत्पादन को मार्गदर्शित करने के लिए संदर्भ छवियों का उपयोग करें

• पाठ संकेतों के साथ संयोजित करें

• स्टाइल ट्रांसफर और कंटेंट ट्रांसफर

• SD 1.5 और SDXL दोनों के साथ काम करता है

एडाप्टर प्रकार

एडाप्टर	उपयोग का मामला	VRAM
IP-Adapter	सामान्य छवि संकेतिंग	8GB
IP-एडाप्टर-प्लस	उच्च गुणवत्ता	10GB
IP-एडाप्टर-फेस	चेहरे-केंद्रित	10GB
IP-एडाप्टर-फुल-फेस	पूर्ण चेहरे का विवरण	12GB

त्वरित तैनाती

Docker इमेज:

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

पोर्ट:

22/tcp
7860/http

कमांड:

pip install diffusers transformers accelerate && \
python ip_adapter_app.py

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

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

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

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

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

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

इंस्टॉलेशन

pip install diffusers transformers accelerate

बेसिक इमेज प्रॉम्प्टिंग

from diffusers import AutoPipelineForText2Image
from diffusers.utils import load_image
import torch

pipe = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16
).to("cuda")

# IP-Adapter लोड करें
pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="sdxl_models",
    weight_name="ip-adapter_sdxl.bin"
)

# संदर्भ छवि लोड करें
ip_image = load_image("reference.jpg")

# छवि संकेत के साथ जनरेट करें
image = pipe(
    prompt="उसी शैली में एक बिल्ली",
    ip_adapter_image=ip_image,
    num_inference_steps=30
).images[0]

image.save("output.png")

स्टाइल ट्रांसफर

from diffusers import AutoPipelineForText2Image
from diffusers.utils import load_image
import torch

pipe = AutoPipelineForText2Image.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
).to("cuda")

pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="models",
    weight_name="ip-adapter_sd15.bin"
)

# शैली संदर्भ (उदा., वैन गॉग की पेंटिंग)
style_image = load_image("van_gogh_starry_night.jpg")

# उस शैली में नया कंटेंट जनरेट करें
image = pipe(
    prompt="एक आधुनिक शहर की स्काईलाइन",
    ip_adapter_image=style_image,
    num_inference_steps=30,
    guidance_scale=7.5
).images[0]

image.save("city_van_gogh.png")

फेस एडाप्टर

चेहरे-केंद्रित जनरेशन के लिए:

from diffusers import AutoPipelineForText2Image
from diffusers.utils import load_image
import torch

pipe = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16
).to("cuda")

# फेस-विशिष्ट एडाप्टर लोड करें
pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="sdxl_models",
    weight_name="ip-adapter-plus-face_sdxl_vit-h.bin"
)

# संदर्भ चेहरा
face_image = load_image("face_reference.jpg")

# पोर्ट्रेट जनरेट करें
image = pipe(
    prompt="पोर्ट्रेट पेंटिंग, कैनवास पर तेल, म्यूज़ियम क्वालिटी",
    ip_adapter_image=face_image,
    num_inference_steps=30
).images[0]

image.save("portrait.png")

कई छवियों का संयोजन

from diffusers import AutoPipelineForText2Image
from diffusers.utils import load_image
import torch

pipe = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16
).to("cuda")

pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="sdxl_models",
    weight_name="ip-adapter_sdxl.bin"
)

# कई संदर्भ छवियां
images = [
    load_image("style1.jpg"),
    load_image("style2.jpg")
]

# दोनों का मिश्रण करके जनरेट करें
image = pipe(
    prompt="लैंडस्केप पेंटिंग",
    ip_adapter_image=images,
    num_inference_steps=30
).images[0]

स्केल नियंत्रण

# एडाप्टर शक्त‍ि सेट करें
pipe.set_ip_adapter_scale(0.6)  # 0.0 से 1.0

# कम स्केल = अधिक पाठ संकेत प्रभाव

# उच्च स्केल = अधिक छवि संकेत प्रभाव

# कई छवियों के साथ प्रति-छवि स्केलिंग
pipe.set_ip_adapter_scale([0.7, 0.3])

ControlNet के साथ

from diffusers import (
    AutoPipelineForText2Image,
    ControlNetModel
)
from diffusers.utils import load_image
import torch

# ControlNet लोड करें
controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_canny",
    torch_dtype=torch.float16
)

pipe = AutoPipelineForText2Image.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

# IP-Adapter लोड करें
pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="models",
    weight_name="ip-adapter_sd15.bin"
)

# शैली छवि
style_image = load_image("style.jpg")

# कंट्रोल छवि (एज मैप)
control_image = load_image("edges.png")

image = pipe(
    prompt="विस्तृत चित्रण",
    image=control_image,
    ip_adapter_image=style_image,
    num_inference_steps=30
).images[0]

Gradio इंटरफ़ेस

import gradio as gr
import torch
from diffusers import AutoPipelineForText2Image
from diffusers.utils import load_image

pipe = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16
).to("cuda")

pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="sdxl_models",
    weight_name="ip-adapter_sdxl.bin"
)

def generate(reference_image, prompt, negative_prompt, scale, steps):
    pipe.set_ip_adapter_scale(scale)

    image = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        ip_adapter_image=reference_image,
        num_inference_steps=steps
    ).images[0]

    return image

demo = gr.Interface(
    fn=generate,
    inputs=[
        gr.Image(type="pil", label="Reference Image"),
        gr.Textbox(label="Prompt", value="high quality"),
        gr.Textbox(label="Negative Prompt", value="ugly, blurry"),
        gr.Slider(0.0, 1.0, value=0.6, label="IP-Adapter Scale"),
        gr.Slider(10, 50, value=30, step=1, label="Steps")
    ],
    outputs=gr.Image(label="Generated Image"),
    title="IP-Adapter Image Prompting"
)

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

बैच स्टाइल ट्रांसफर

from diffusers import AutoPipelineForText2Image
from diffusers.utils import load_image
import torch
import os

pipe = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16
).to("cuda")

pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="sdxl_models",
    weight_name="ip-adapter_sdxl.bin"
)

# शैली संदर्भ
style_image = load_image("art_style.jpg")

# जनरेट करने के लिए विषय
subjects = [
    "एक पर्वत दृश्य",
    "रात में एक शहर",
    "शरद में एक जंगल",
    "एक समुद्र तट का सूर्यास्त",
    "एक बर्फीला गाँव"
]

output_dir = "./styled_outputs"
os.makedirs(output_dir, exist_ok=True)

for i, subject in enumerate(subjects):
    print(f"Generating {i+1}/{len(subjects)}: {subject}")

    image = pipe(
        prompt=subject,
        ip_adapter_image=style_image,
        num_inference_steps=30
    ).images[0]

    image.save(f"{output_dir}/styled_{i:03d}.png")

उपयोग के मामले

प्रोडक्ट फ़ोटोग्राफ़ी स्टाइल

# संदर्भ: पेशेवर उत्पाद फोटो
style = load_image("product_photo_reference.jpg")

image = pipe(
    prompt="सफेद पृष्ठभूमि पर लाल स्नीकर्स",
    ip_adapter_image=style,
    num_inference_steps=30
).images[0]

कलात्मक स्टाइल ट्रांसफर

# संदर्भ: प्रसिद्ध पेंटिंग
style = load_image("monet_painting.jpg")

image = pipe(
    prompt="बाग में एक महिला का पोर्ट्रेट",
    ip_adapter_image=style,
    num_inference_steps=30
).images[0]

ब्रांड संगति

# संदर्भ: ब्रांड स्टाइल गाइड छवि
style = load_image("brand_style.jpg")

prompts = [
    "वेबसाइट हीरो बैनर",
    "सोशल मीडिया पोस्ट",
    "ईमेल न्यूज़लेट्टर हेडर"
]

for prompt in prompts:
    image = pipe(prompt=prompt, ip_adapter_image=style).images[0]

मेमोरी अनुकूलन

pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()

# बहुत सीमित VRAM के लिए
pipe.enable_sequential_cpu_offload()

प्रदर्शन

मॉडल	GPU	समय
SD 1.5 + IP-एडाप्टर	RTX 3090	~5s
SDXL + IP-एडाप्टर	RTX 3090	~12s
SDXL + IP-एडाप्टर	RTX 4090	~8s
SDXL + IP-एडाप्टर-प्लस	RTX 4090	~10s

समस्याओं का निवारण

शैली लागू नहीं हुई

• ip_adapter_scale बढ़ाएँ

• ज़्यादा स्पष्ट संदर्भ छवि का उपयोग करें

• सुनिश्चित करें कि एडाप्टर सही तरीके से लोड हुआ है

अत्यधिक संदर्भ प्रभाव

• ip_adapter_scale घटाएँ

• अधिक विशिष्ट पाठ संकेत

• guidance_scale बढ़ाएँ

मेमोरी समस्याएँ

• CPU ऑफलोड सक्षम करें

• SDXL के बजाय SD 1.5 का उपयोग करें

• रिज़ॉल्यूशन कम करें

लागत अनुमान

सामान्य 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 टोकन के साथ

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

अगले कदम

• InstantID - चेहरे की पहचान

• ControlNet - संरचना नियंत्रण

• Stable Diffusion WebUI - IP-Adapter एक्सटेंशन