# InvokeAI InvokeAI एक पेशेवर-ग्रेड Stable Diffusion टूलकिट है जिसमें एक उन्नत नोड-आधारित कैनवास एडिटर, पूर्ण SDXL/SD1.5/SD2.x समर्थन, ControlNet, IP-Adapter, LoRA प्रबंधन और एक परिष्कृत वेब UI शामिल है। यह कलाकारों और क्रिएटिव पेशेवरों के लिए डिज़ाइन किया गया है जिन्हें अपनी इमेज जनरेशन वर्कफ़्लो पर सटीक नियंत्रण चाहिए। CLORE.AI के उच्च-VRAM GPU आपको कई ControlNet एक साथ चलते हुए पूर्ण रिज़ॉल्यूशन पर SDXL चलाने देते हैं। {% hint style="success" %} सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें से किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace). {% endhint %} ## सर्वर आवश्यकताएँ | पैरामीटर | न्यूनतम | सिफारिश की गई | | -------- | -------------------- | ------------------------ | | RAM | 12 GB | 32 GB+ | | VRAM | 6 GB | 12 GB+ | | डिस्क | 40 GB | 200 GB+ | | GPU | NVIDIA GTX 1060 6GB+ | RTX 3090, RTX 4090, A100 | {% hint style="info" %} बिना समझौते के SDXL (1024×1024) के लिए 12 GB VRAM की सिफारिश की जाती है। SD1.5 (512×512 या 768×768) के लिए 6 GB VRAM पर्याप्त है। अधिक VRAM = उच्चतर रिज़ॉल्यूशन, तेज़ जनरेशन, और अधिक ControlNets एक साथ। {% endhint %} ## CLORE.AI पर त्वरित तैनाती **Docker इमेज:** `ghcr.io/invoke-ai/invokeai:latest` **पोर्ट्स:** `22/tcp`, `9090/http` **पर्यावरण चर:** | चर | उदाहरण | विवरण | | --------------- | ----------- | ------------------------------------ | | `INVOKEAI_ROOT` | `/invokeai` | मॉडल और आउटपुट के लिए रूट निर्देशिका | ## चरण-दर-चरण सेटअप ### 1. CLORE.AI पर एक GPU सर्वर किराए पर लें पर जाएँ [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace) और खोजें: * **बजट क्रिएटिव कार्य**: RTX 3080/3090 (10–24 GB VRAM) * **प्रोफेशनल SDXL**: RTX 4090 (24 GB VRAM) * **अधिकतम गुणवत्ता**: A100 80GB — कई मॉडल एक साथ चलाएँ ### 2. अपने सर्वर में SSH करें ```bash ssh -p root@ ``` ### 3. InvokeAI निर्देशिका संरचना बनाएँ ```bash mkdir -p /root/invokeai ``` ### 4. InvokeAI Docker इमेज खींचें ```bash docker pull ghcr.io/invoke-ai/invokeai:latest ``` ### 5. InvokeAI लॉन्च करें **बुनियादी लॉन्च:** ```bash 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 ``` **कस्टम रूट और संसाधन बढ़ाने के साथ:** ```bash 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 सर्वर):** ```bash 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. इनिशियलाइज़ेशन की प्रतीक्षा करें ```bash docker logs -f invokeai ``` इसके लिए देखें: `Uvicorn running on http://0.0.0.0:9090` ### 7. CLORE.AI HTTP प्रॉक्सी के माध्यम से एक्सेस करें अपना CLORE.AI डैशबोर्ड खोलें और ढूँढें `http_pub` पोर्ट 9090 के लिए URL: ``` https://-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 ट्रिगर के साथ उदाहरण प्रॉम्प्ट: ``` एक महिला का पोर्ट्रेट, , हाइपररियलिस्टिक, स्टूडियो लाइटिंग ``` ### उदाहरण 4: स्टाइल ट्रांसफर के लिए IP-Adapter का उपयोग 1. सक्षम करें **IP-Adapter** जनरेशन पैनल में 2. एक संदर्भ स्टाइल इमेज अपलोड करें 3. वज़न सेट करें (0.5 = सूक्ष्म प्रभाव, 1.0 = मजबूत प्रभाव) 4. किसी भी प्रॉम्प्ट के साथ जनरेट करें — आउटपुट संदर्भ स्टाइल से मेल खाएगा ### उदाहरण 5: API उपयोग (Headless) InvokeAI प्रोग्रामेटिक उपयोग के लिए एक REST API एक्सपोज़ करता है: ```python 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`: ```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):** ```yaml मेमोरी/प्रदर्शन: ram: 24.0 vram: 0.5 # सक्रिय मॉडल के लिए 50% रखें lazy_offload: false # ऑफलोड न करें — पर्याप्त VRAM ``` **RTX 3080 (10 GB VRAM):** ```yaml मेमोरी/प्रदर्शन: ram: 16.0 vram: 0.25 lazy_offload: true ``` **छोटे GPU (6-8 GB VRAM):** ```yaml मेमोरी/प्रदर्शन: 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 में: ```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 सुलभ नहीं है ```bash # जांचें कि कंटेनर चल रहा है या नहीं docker ps | grep invokeai # त्रुटियों के लिए लॉग जांचें docker logs invokeai 2>&1 | tail -50 # पोर्ट मैपिंग सत्यापित करें docker port invokeai ``` सुनिश्चित करें कि पोर्ट 9090 आपके CLORE.AI ऑर्डर की पोर्ट कॉन्फ़िगरेशन में सूचीबद्ध है। ### समस्या: कंटेनर के अंदर मॉडल डाउनलोड विफल हो रहा है ```bash # 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` फ्लैग ### समस्या: कंटेनर शुरू नहीं होगा ```bash docker logs invokeai # सामान्य: पोर्ट 9090 पहले से उपयोग में है # समाधान: docker stop $(docker ps -q --filter "publish=9090") docker start invokeai ``` *** ## लिंक * [GitHub](https://github.com/invoke-ai/InvokeAI) * [डॉक्यूमेंटेशन](https://invoke-ai.github.io/InvokeAI/) * [Docker Hub / GHCR](https://github.com/invoke-ai/InvokeAI/pkgs/container/invokeai) * [CivitAI (मॉडल)](https://civitai.com) * [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace) *** ## 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](https://clore.ai/marketplace) GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।