InvokeAI

Node-आधारित कैनवस के साथ InvokeAI पेशेवर Stable Diffusion उपकरणकिट को Clore.ai GPUs पर चलाएँ

InvokeAI एक पेशेवर-ग्रेड Stable Diffusion टूलकिट है जिसमें एक उन्नत नोड-आधारित कैनवास एडिटर, पूर्ण SDXL/SD1.5/SD2.x समर्थन, ControlNet, IP-Adapter, LoRA प्रबंधन और एक परिष्कृत वेब UI शामिल है। यह कलाकारों और क्रिएटिव पेशेवरों के लिए डिज़ाइन किया गया है जिन्हें अपनी इमेज जनरेशन वर्कफ़्लो पर सटीक नियंत्रण चाहिए। CLORE.AI के उच्च-VRAM GPU आपको कई ControlNet एक साथ चलते हुए पूर्ण रिज़ॉल्यूशन पर SDXL चलाने देते हैं।

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

सर्वर आवश्यकताएँ

पैरामीटर	न्यूनतम	सिफारिश की गई
RAM	12 GB	32 GB+
VRAM	6 GB	12 GB+
डिस्क	40 GB	200 GB+
GPU	NVIDIA GTX 1060 6GB+	RTX 3090, RTX 4090, A100

बिना समझौते के SDXL (1024×1024) के लिए 12 GB VRAM की सिफारिश की जाती है। SD1.5 (512×512 या 768×768) के लिए 6 GB VRAM पर्याप्त है। अधिक VRAM = उच्चतर रिज़ॉल्यूशन, तेज़ जनरेशन, और अधिक ControlNets एक साथ।

CLORE.AI पर त्वरित तैनाती

Docker इमेज: ghcr.io/invoke-ai/invokeai:latest

पोर्ट्स: 22/tcp, 9090/http

पर्यावरण चर:

चर	उदाहरण	विवरण
INVOKEAI_ROOT	/invokeai	मॉडल और आउटपुट के लिए रूट निर्देशिका

चरण-दर-चरण सेटअप

1. CLORE.AI पर एक GPU सर्वर किराए पर लें

पर जाएँ CLORE.AI मार्केटप्लेस और खोजें:

• बजट क्रिएटिव कार्य: RTX 3080/3090 (10–24 GB VRAM)

• प्रोफेशनल SDXL: RTX 4090 (24 GB VRAM)

• अधिकतम गुणवत्ता: A100 80GB — कई मॉडल एक साथ चलाएँ

2. अपने सर्वर में SSH करें

ssh -p <PORT> root@<SERVER_IP>

3. InvokeAI निर्देशिका संरचना बनाएँ

mkdir -p /root/invokeai

4. InvokeAI Docker इमेज खींचें

docker pull ghcr.io/invoke-ai/invokeai:latest

5. InvokeAI लॉन्च करें

बुनियादी लॉन्च:

docker run -d \
  --name invokeai \
  --gpus all \
  -p 9090:9090 \
  -v /root/invokeai:/invokeai \
  -e INVOKEAI_ROOT=/invokeai \
  ghcr.io/invoke-ai/invokeai:latest \
  invokeai-web --host 0.0.0.0 --port 9090

कस्टम रूट और संसाधन बढ़ाने के साथ:

docker run -d \
  --name invokeai \
  --gpus all \
  --shm-size 8g \
  -p 9090:9090 \
  -v /root/invokeai:/invokeai \
  -v /root/models:/root/models \
  -e INVOKEAI_ROOT=/invokeai \
  ghcr.io/invoke-ai/invokeai:latest \
  invokeai-web --host 0.0.0.0 --port 9090

विशिष्ट GPU के साथ (मल्टी-GPU सर्वर):

docker run -d \
  --name invokeai \
  --gpus '"device=0"' \
  -p 9090:9090 \
  -v /root/invokeai:/invokeai \
  -e INVOKEAI_ROOT=/invokeai \
  -e CUDA_VISIBLE_DEVICES=0 \
  ghcr.io/invoke-ai/invokeai:latest \
  invokeai-web --host 0.0.0.0 --port 9090

6. इनिशियलाइज़ेशन की प्रतीक्षा करें

docker logs -f invokeai

इसके लिए देखें: Uvicorn running on http://0.0.0.0:9090

7. CLORE.AI HTTP प्रॉक्सी के माध्यम से एक्सेस करें

अपना CLORE.AI डैशबोर्ड खोलें और ढूँढें http_pub पोर्ट 9090 के लिए URL:

https://<order-id>-9090.clore.ai/

यह आपके ब्राउज़र में पूरा InvokeAI वेब इंटरफ़ेस खोलता है।

8. अपना पहला मॉडल डाउनलोड करें

InvokeAI UI में:

1. पर क्लिक करें Model Manager (बाएँ साइडबार में 큐ब आइकन)

2. पर क्लिक करें Add Model → HuggingFace

3. मॉडल ID दर्ज करें (उदा., stabilityai/stable-diffusion-xl-base-1.0)

4. पर क्लिक करें Add Model

या सीधे CivitAI से डाउनलोड करें:

1. पर जाएँ Model Manager → Add Model → URL

2. CivitAI डाउनलोड URL पेस्ट करें

3. मॉडल प्रकार सेट करें (Checkpoint, LoRA, आदि)

---

उपयोग के उदाहरण

उदाहरण 1: वेब UI के माध्यम से बुनियादी इमेज जनरेशन

1. अपने CLORE.AI http_pub URL पर InvokeAI खोलें

2. पर क्लिक करें टेक्स्ट से इमेज वर्कफ़्लो चयनकर्ता में

3. प्रॉम्प्ट दर्ज करें: "एक भव्य ड्रैगन जो क्रिस्टल पर्वत पर बैठा है, डिजिटल आर्ट, 4k"

4. नकारात्मक प्रॉम्प्ट सेट करें: "धुंधला, कम गुणवत्ता, वॉटरमार्क"

5. रिज़ॉल्यूशन सेट करें 1024x1024 (SDXL) या 512x512 (SD1.5)

6. पर क्लिक करें Invoke

उदाहरण 2: नोड-आधारित कैनवास का उपयोग

वर्कफ़्लो संपादक InvokeAI की विशेष विशेषता है:

1. पर क्लिक करें Workflows ऊपर नेव में

2. पर क्लिक करें New Workflow

3. नोड जोड़ें: Text → Image, कनेक्ट करें Save Image

4. एक जोड़ें ControlNet मार्गदर्शित जनरेशन के लिये नोड:

   • राइट-क्लिक → Add Node → ControlNet

   • अपनी संदर्भ छवि कनेक्ट करें

   • प्रोसेसर चुनें: Canny, Depth, Pose, आदि

5. पर क्लिक करें Invoke पूर्ण पाइपलाइन चलाने के लिए

उदाहरण 3: LoRA का उपयोग

1. CivitAI से एक LoRA डाउनलोड करें (Model Manager → URL import के माध्यम से)

2. जनरेशन पैनल में, खोजें LoRA सेक्शन

3. पर क्लिक करें + और अपना LoRA चुनें

4. वज़न सेट करें (0.5–1.0 सामान्य)

5. प्रॉम्प्ट में ट्रिगर शब्द जोड़ें (CivitAI मॉडल पेज पर सूचीबद्ध)

LoRA ट्रिगर के साथ उदाहरण प्रॉम्प्ट:

एक महिला का पोर्ट्रेट, <lora:detail-tweaker:0.8>, हाइपररियलिस्टिक, स्टूडियो लाइटिंग

उदाहरण 4: स्टाइल ट्रांसफर के लिए IP-Adapter का उपयोग

1. सक्षम करें IP-Adapter जनरेशन पैनल में

2. एक संदर्भ स्टाइल इमेज अपलोड करें

3. वज़न सेट करें (0.5 = सूक्ष्म प्रभाव, 1.0 = मजबूत प्रभाव)

4. किसी भी प्रॉम्प्ट के साथ जनरेट करें — आउटपुट संदर्भ स्टाइल से मेल खाएगा

उदाहरण 5: API उपयोग (Headless)

InvokeAI प्रोग्रामेटिक उपयोग के लिए एक REST API एक्सपोज़ करता है:

import requests
import time
import base64

BASE_URL = "http://localhost:9090"  # या आपका CLORE.AI http_pub URL

# उपलब्ध मॉडल सूचीबद्ध करें
models = requests.get(f"{BASE_URL}/api/v1/models").json()
print("Available models:", [m["name"] for m in models.get("items", [])])

# एक जनरेशन कतार में डालें
payload = {
    "batch": {
        "graph": {
            "nodes": {
                "text_encoder": {
                    "type": "compel",
                    "id": "text_encoder",
                    "prompt": "सूर्यास्त पर एक भविष्यवादी शहर, फोटोरियलिस्टिक",
                },
                "noise": {
                    "type": "noise",
                    "id": "noise",
                    "width": 1024,
                    "height": 1024,
                    "seed": 42,
                },
                "denoise_latents": {
                    "type": "denoise_latents",
                    "id": "denoise_latents",
                    "steps": 30,
                    "cfg_scale": 7.5,
                    "scheduler": "dpmpp_2m",
                },
                "l2i": {
                    "type": "l2i",
                    "id": "l2i",
                },
            },
            "edges": [],
        }
    }
}

# सरल: कतार API का उपयोग करें
response = requests.post(f"{BASE_URL}/api/v1/queue/default/enqueue_batch", json=payload)
print(response.status_code)

---

कॉन्फ़िगरेशन

invokeai.yaml कॉन्फ़िगरेशन फ़ाइल

स्थित है /root/invokeai/invokeai.yaml:

InvokeAI:
  वेब सर्वर:
    host: 0.0.0.0
    port: 9090
    allow_origins: []
    
  विशेषताएँ:
    esrgan: true          # ESRGAN अपस्केलिंग
    internet_available: true
    
  मेमोरी/प्रदर्शन:
    ram: 12.0             # मॉडल कैश के लिए अधिकतम RAM (GB)
    vram: 0.25            # मॉडल कैश के लिए VRAM का अंश
    lazy_offload: true    # उपयोग में नहीं होने पर मॉडल को CPU पर ऑफलोड करें
    
  पथ:
    models_path: /invokeai/models
    db_path: /invokeai/databases/invokeai.db
    outdir: /invokeai/outputs

GPU के अनुसार सिफारिश की गई सेटिंग्स

RTX 3090 / 4090 (24 GB VRAM):

मेमोरी/प्रदर्शन:
  ram: 24.0
  vram: 0.5   # सक्रिय मॉडल के लिए 50% रखें
  lazy_offload: false  # ऑफलोड न करें — पर्याप्त VRAM

RTX 3080 (10 GB VRAM):

मेमोरी/प्रदर्शन:
  ram: 16.0
  vram: 0.25
  lazy_offload: true

छोटे GPU (6-8 GB VRAM):

मेमोरी/प्रदर्शन:
  ram: 8.0
  vram: 0.1
  lazy_offload: true

---

प्रदर्शन सुझाव

1. तेज़ जनरेशन के लिए SDXL-Turbo या SDXL-Lightning का उपयोग करें

SDXL बेस (25–50 स्टेप्स) के बजाय उपयोग करें:

• SDXL-Turbo: 1–4 स्टेप्स, रीयलटाइम जनरेशन

• SDXL-Lightning: 4–8 स्टेप्स, लगभग SDXL गुणवत्ता

Model Manager → HuggingFace के माध्यम से डाउनलोड:

• stabilityai/sdxl-turbo

• ByteDance/SDXL-Lightning

2. सही शेड्यूलर चुनें

Scheduler	गुणवत्ता	गति	सबसे अच्छा उपयोग
euler_a	अच्छा	तेज़	सामान्य उपयोग
dpmpp_2m	अत्युत्तम	तेज़	फोटोरियलिस्टिक
dpmpp_2m_sde	अत्युत्तम	मध्यम	उच्च विवरण
ddim	अच्छा	तेज़	इनपेंटिंग
lms	अच्छा	तेज़	कलात्मक शैलियाँ

3. xFormers मेमोरी ऑप्टिमाइज़ेशन सक्षम करें

InvokeAI यह उपलब्ध होने पर स्वचालित रूप से सक्षम करता है। लॉग में सत्यापित करें:

xFormers उपलब्ध है

4. मॉडल कैशिंग का उपयोग करें

सबसे अधिक उपयोग किए जाने वाले मॉडलों को कैश में रखें। invokeai.yaml में:

ram: 32.0  # बड़ा = अधिक मॉडल कैश किये जा सकते हैं

5. बड़े रिज़ॉल्यूशन के लिए टाइलिंग करें

उन इमेज के लिए जो आपके VRAM से बड़ी हैं (उदा., 12 GB GPU पर 2048×2048):

• उपयोग करें Tiled VAE वर्कफ़्लो एडिटर में

• या 1024×1024 पर जनरेट करें फिर अपस्केल करें ESRGAN

---

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

समस्या: "CUDA out of memory"

RuntimeError: CUDA out of memory

समाधान:

1. रिज़ॉल्यूशन कम करें (1024→768 या 512)

2. बैच साइज को 1 पर घटाएँ

3. invokeai.yaml में lazy offloading सक्षम करें

4. छोटा मॉडल उपयोग करें (SDXL के बजाय SD1.5)

समस्या: वेब UI सुलभ नहीं है

# जांचें कि कंटेनर चल रहा है या नहीं
docker ps | grep invokeai

# त्रुटियों के लिए लॉग जांचें
docker logs invokeai 2>&1 | tail -50

# पोर्ट मैपिंग सत्यापित करें
docker port invokeai

सुनिश्चित करें कि पोर्ट 9090 आपके CLORE.AI ऑर्डर की पोर्ट कॉन्फ़िगरेशन में सूचीबद्ध है।

समस्या: कंटेनर के अंदर मॉडल डाउनलोड विफल हो रहा है

# exec के माध्यम से मैन्युअल रूप से डाउनलोड करें
docker exec -it invokeai bash
cd /invokeai/models/main
wget "https://civitai.com/api/download/models/XXX" -O mymodel.safetensors

समस्या: धीमी जनरेशन (< 1 it/s)

• GPU उपयोगिता जांचें: docker exec -it invokeai nvidia-smi

• लॉग में सुनिश्चित करें कि xFormers सक्षम है

• कोशिश करें euler_a scheduler (सबसे तेज़)

समस्या: काली/टूटी हुई छवियाँ

आम तौर पर VAE समस्या। कोशिश करें:

1. Model Manager → Edit model → VAE बदलें sdxl-vae-fp16-fix

2. या जोड़ें --fp32-vae फ्लैग

समस्या: कंटेनर शुरू नहीं होगा

docker logs invokeai
# सामान्य: पोर्ट 9090 पहले से उपयोग में है
# समाधान:
docker stop $(docker ps -q --filter "publish=9090")
docker start invokeai

---

लिंक

• GitHub

• डॉक्यूमेंटेशन

• Docker Hub / GHCR

• CivitAI (मॉडल)

• CLORE.AI मार्केटप्लेस

---

Clore.ai GPU सिफारिशें

उपयोग केस	सिफारिश की गई GPU	Clore.ai पर अनुमानित लागत
डेवलपमेंट/टेस्टिंग	RTX 3090 (24GB)	~$0.12/gpu/hr
प्रोडक्शन	RTX 4090 (24GB)	~$0.70/gpu/hr
बड़े पैमाने पर	A100 80GB	~$1.20/gpu/hr

💡 इस गाइड के सभी उदाहरण तैनात किए जा सकते हैं Clore.ai GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।