कैंडिंस्की

Clore.ai पर Kandinsky के बहुभाषी मॉडल के साथ इमेज जेनरेट करें

मल्टीलिंग्वल टेक्स्ट समझ के साथ छवियाँ उत्पन्न करें।

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

कैंडिंस्की क्या है?

कैंडिंस्की Sber AI द्वारा विकसित एक इमेज जनरेशन मॉडल है:

• मजबूत बहुभाषी टेक्स्ट समझ

• उच्च गुणवत्ता वाली छवि जनरेशन

• इमेज मिश्रण और इंटरपोलेशन

• इनपेंटिंग और आउटपेंटिंग समर्थन

• ओपन सोर्स वेट्स

संसाधन

• GitHub: ai-forever/Kandinsky-3

• HuggingFace: kandinsky-community

• पेपर: कैंडिंस्की पेपर

मॉडल वर्ज़न

संस्करण	रिज़ॉल्यूशन	गुणवत्ता	स्पीड
कैंडिंस्की 2.1	768x768	अच्छा	तेज़
कैंडिंस्की 2.2	1024x1024	बेहतर	मध्यम
कैंडिंस्की 3	1024x1024	सर्वोत्तम	धीमा

हार्डवेयर आवश्यकताएँ

मॉडल	VRAM	अनुशंसित GPU
कैंडिंस्की 2.2	8GB	RTX 3070
कैंडिंस्की 3	12GB	RTX 3090
कैंडिंस्की 3 (उच्च रिज़ॉल्यूशन)	16GB	RTX 4090

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

Docker इमेज:

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

पोर्ट:

22/tcp
7860/http

कमांड:

pip install diffusers transformers accelerate gradio && \
python -c "
import gradio as gr
import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    'kandinsky-community/kandinsky-3',
    variant='fp16',
    torch_dtype=torch.float16
).to('cuda')

def generate(prompt, negative, steps, guidance, seed):
    generator = torch.Generator('cuda').manual_seed(seed) if seed > 0 else None
    image = pipe(
        prompt=prompt,
        negative_prompt=negative,
        num_inference_steps=steps,
        guidance_scale=guidance,
        generator=generator
    ).images[0]
    return image

gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label='Prompt'),
        gr.Textbox(label='Negative Prompt', value='low quality, blurry'),
        gr.Slider(10, 100, value=50, label='Steps'),
        gr.Slider(1, 20, value=4, label='Guidance'),
        gr.Number(value=-1, label='Seed')
    ],
    outputs=gr.Image(),
    title='Kandinsky 3'
).launch(server_name='0.0.0.0', server_port=7860)
"

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

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

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

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

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

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

इंस्टॉलेशन

pip install diffusers transformers accelerate torch

मूल उपयोग

कैंडिंस्की 3

import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    "kandinsky-community/kandinsky-3",
    variant="fp16",
    torch_dtype=torch.float16
)
pipe.to("cuda")

image = pipe(
    prompt="A cat astronaut floating in space, digital art, vibrant colors",
    num_inference_steps=50,
    guidance_scale=4.0
).images[0]

image.save("cat_astronaut.png")

कैंडिंस्की 2.2

import torch
from diffusers import KandinskyV22Pipeline, KandinskyV22PriorPipeline

# Load prior (text encoder)
prior = KandinskyV22PriorPipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-prior",
    torch_dtype=torch.float16
).to("cuda")

# Load decoder
decoder = KandinskyV22Pipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder",
    torch_dtype=torch.float16
).to("cuda")

# Generate image embeddings
prompt = "A beautiful sunset over mountains, oil painting style"
image_embeds, negative_embeds = prior(
    prompt=prompt,
    guidance_scale=1.0
).to_tuple()

# Generate image
image = decoder(
    image_embeds=image_embeds,
    negative_image_embeds=negative_embeds,
    height=768,
    width=768,
    num_inference_steps=50
).images[0]

image.save("sunset.png")

मल्टीलिंग्वल प्रॉम्प्ट्स

कैंडिंस्की कई भाषाओं का समर्थन करता है:

import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    "kandinsky-community/kandinsky-3",
    variant="fp16",
    torch_dtype=torch.float16
).to("cuda")

# अंग्रेज़ी
image_en = pipe("A red fox in a snowy forest").images[0]

# रूसी
image_ru = pipe("Красная лиса в снежном лесу").images[0]

# चीनी
image_zh = pipe("雪林中的红狐狸").images[0]

# जर्मन
image_de = pipe("Ein roter Fuchs im verschneiten Wald").images[0]

# सभी समान छवियाँ उत्पन्न करते हैं!

इमेज मिश्रण

import torch
from diffusers import KandinskyV22PriorPipeline, KandinskyV22Pipeline
from diffusers.utils import load_image

prior = KandinskyV22PriorPipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-prior",
    torch_dtype=torch.float16
).to("cuda")

decoder = KandinskyV22Pipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder",
    torch_dtype=torch.float16
).to("cuda")

# मिश्रित करने के लिए दो प्रॉम्प्ट्स
prompt1 = "A cat"
prompt2 = "A dog"

# दोनों के लिए एम्बेडिंग प्राप्त करें
embeds1, neg1 = prior(prompt1).to_tuple()
embeds2, neg2 = prior(prompt2).to_tuple()

# एम्बेडिंग्स मिलाएँ (प्रत्येक 50%)
mixed_embeds = 0.5 * embeds1 + 0.5 * embeds2
mixed_neg = 0.5 * neg1 + 0.5 * neg2

# मिश्रित छवि जनरेट करें
image = decoder(
    image_embeds=mixed_embeds,
    negative_image_embeds=mixed_neg,
    height=768,
    width=768
).images[0]

image.save("cat_dog_mix.png")

इनपेंटिंग

import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image

pipe = AutoPipelineForInpainting.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder-inpaint",
    torch_dtype=torch.float16
).to("cuda")

# छवि और मास्क लोड करें
image = load_image("photo.png")
mask = load_image("mask.png")

# इनपेंट
result = pipe(
    prompt="A golden crown",
    image=image,
    mask_image=mask,
    num_inference_steps=50
).images[0]

result.save("inpainted.png")

इमेज-टू-इमेज

import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import load_image

pipe = AutoPipelineForImage2Image.from_pretrained(
    "kandinsky-community/kandinsky-3",
    variant="fp16",
    torch_dtype=torch.float16
).to("cuda")

init_image = load_image("sketch.png")

image = pipe(
    prompt="A detailed digital painting of a castle, fantasy art",
    image=init_image,
    strength=0.75,
    num_inference_steps=50
).images[0]

image.save("castle.png")

बैच जनरेशन

import torch
from diffusers import AutoPipelineForText2Image
import os

pipe = AutoPipelineForText2Image.from_pretrained(
    "kandinsky-community/kandinsky-3",
    variant="fp16",
    torch_dtype=torch.float16
).to("cuda")

prompts = [
    "A serene Japanese garden with cherry blossoms",
    "A cyberpunk city at night with neon lights",
    "An ancient library filled with magical books",
    "A cozy cabin in the mountains during winter"
]

os.makedirs("outputs", exist_ok=True)

for i, prompt in enumerate(prompts):
    image = pipe(
        prompt=prompt,
        num_inference_steps=50,
        guidance_scale=4.0
    ).images[0]

    image.save(f"outputs/image_{i}.png")
    print(f"Generated: {prompt[:30]}...")

    torch.cuda.empty_cache()

Gradio इंटरफ़ेस

import gradio as gr
import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    "kandinsky-community/kandinsky-3",
    variant="fp16",
    torch_dtype=torch.float16
).to("cuda")

def generate(prompt, negative_prompt, steps, guidance, width, height, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    image = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_inference_steps=steps,
        guidance_scale=guidance,
        width=width,
        height=height,
        generator=generator
    ).images[0]

    return image

demo = gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label="Prompt", placeholder="Describe your image..."),
        gr.Textbox(label="Negative Prompt", value="low quality, blurry, distorted"),
        gr.Slider(10, 100, value=50, step=5, label="Steps"),
        gr.Slider(1, 20, value=4, step=0.5, label="Guidance Scale"),
        gr.Slider(512, 1024, value=1024, step=64, label="Width"),
        gr.Slider(512, 1024, value=1024, step=64, label="Height"),
        gr.Number(value=-1, label="Seed (-1 for random)")
    ],
    outputs=gr.Image(label="Generated Image"),
    title="Kandinsky 3 - Image Generation",
    description="Generate images with multilingual prompts. Running on CLORE.AI."
)

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

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

import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    "kandinsky-community/kandinsky-3",
    variant="fp16",
    torch_dtype=torch.float16
)

# मेमोरी ऑप्टिमाइज़ेशन सक्षम करें
pipe.enable_model_cpu_offload()

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

# अटेंशन स्लाइसिंग सक्षम करें
pipe.enable_attention_slicing()

image = pipe(
    prompt="A beautiful landscape",
    num_inference_steps=50
).images[0]

प्रदर्शन

मॉडल	रिज़ॉल्यूशन	GPU	समय
कैंडिंस्की 3	1024x1024	RTX 3090	15s
कैंडिंस्की 3	1024x1024	RTX 4090	10s
कैंडिंस्की 2.2	768x768	RTX 3090	8s
कैंडिंस्की 2.2	768x768	RTX 4090	5s

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

आउट ऑफ़ मेमोरी

समस्या: जनरेट करते समय CUDA OOM

समाधान:

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

• रिज़ॉल्यूशन घटाएँ

• 3 के बजाय Kandinsky 2.2 का उपयोग करें

• अटेंशन स्लाइसिंग सक्षम करें

pipe.enable_model_cpu_offload()
pipe.enable_attention_slicing()

खराब टेक्स्ट रेंडरिंग

समस्या: छवियों में टेक्स्ट गलत दिखता है

समाधान:

• कैंडिंस्की टेक्स्ट रेंडरिंग में संघर्ष करता है (ज्यादातर डिफ्यूजन मॉडलों की तरह)

• पोस्ट-प्रोसेसिंग में टेक्स्ट जोड़ें

• ऐसे प्रॉम्प्ट्स का उपयोग करें जो टेक्स्ट से बचें

रंग गलत दिखते हैं

समस्या: छवि के रंग फीके या अतिसंतृप्त हैं

समाधान:

• गाइडेंस स्केल समायोजित करें (3-6 रेंज आज़माएँ)

• प्रॉम्प्ट में रंग वरीयताएँ निर्दिष्ट करें

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

धीमा जनरेशन

समस्या: जनरेट करने में बहुत समय लगता है

समाधान:

• इन्फरेंस स्टेप्स घटाएँ (अक्सर 30 पर्याप्त होते हैं)

• fp16 प्रिसिजन का उपयोग करें

• तेज़ परिणामों के लिए Kandinsky 2.2 का उपयोग करें

• प्रिव्यू के लिए रिज़ॉल्यूशन घटाएँ

अन्य मॉडलों के साथ तुलना

फ़ीचर	कैंडिंस्की 3	SDXL	FLUX
बहुभाषी	उत्कृष्ट	सीमित	सीमित
छवि गुणवत्ता	उच्च	बहुत उच्च	सबसे ऊँचा
स्पीड	मध्यम	मध्यम	धीमा
VRAM	12GB	12GB	24GB
इनपेंटिंग	हां	हां	सीमित

लागत अनुमान

सामान्य 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 मार्केटप्लेस वर्तमान दरों के लिए।

अगले कदम

• FLUX जनरेशन - उच्चतम गुणवत्ता वाली छवियाँ

• स्टेबल डिफ्यूज़न - सबसे लोकप्रिय विकल्प

• पिक्सआर्ट - तेज़ जनरेशन

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