Kandinsky

Générez des images avec le modèle multilingue de Kandinsky sur Clore.ai

Générez des images grâce à une puissante compréhension multilingue du texte.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Qu’est-ce que Kandinsky ?

Kandinsky est un modèle de génération d’images développé par Sber AI :

• Compréhension multilingue du texte robuste

• Génération d’images de haute qualité

• Fusion et interpolation d’images

• Prise en charge de l’inpainting et de l’outpainting

• Poids open source

Ressources

• GitHub : ai-forever/Kandinsky-3

• HuggingFace : kandinsky-community

• Article : Article Kandinsky

Versions du modèle

Version	Résolution	Qualité	Vitesse
Kandinsky 2.1	768x768	Bon	Rapide
Kandinsky 2.2	1024x1024	Meilleur	Moyen
Kandinsky 3	1024x1024	Meilleur	Plus lent

Configuration matérielle requise

Modèle	VRAM	GPU recommandé
Kandinsky 2.2	8 Go	RTX 3070
Kandinsky 3	12 Go	RTX 3090
Kandinsky 3 (haute résolution)	16 Go	RTX 4090

Déploiement rapide

Image Docker :

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

Ports :

22/tcp
7860/http

Commande :

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='Instruction'),
        gr.Textbox(label='Prompt négatif', value='faible qualité, flou'),
        gr.Slider(10, 100, value=50, label='Étapes'),
        gr.Slider(1, 20, value=4, label='Guidage'),
        gr.Number(value=-1, label='Graine')
    ],
    outputs=gr.Image(),
    title='Kandinsky 3'
).launch(server_name='0.0.0.0', server_port=7860)
"

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Accédez à Mes commandes la page

2. Cliquez sur votre commande

3. Trouvez le http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://YOUR_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Installation

pip install diffusers transformers accelerate torch

Utilisation de base

Kandinsky 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="Un chat astronaute flottant dans l’espace, art numérique, couleurs vives",
    num_inference_steps=50,
    guidance_scale=4.0
).images[0]

image.save("cat_astronaut.png")

Kandinsky 2.2

import torch
from diffusers import KandinskyV22Pipeline, KandinskyV22PriorPipeline

# Charger le prior (encodeur de texte)
prior = KandinskyV22PriorPipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-prior",
    torch_dtype=torch.float16
).to("cuda")

# Charger le décodeur
decoder = KandinskyV22Pipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder",
    torch_dtype=torch.float16
).to("cuda")

# Générer des embeddings d’image
prompt = "Un magnifique coucher de soleil sur des montagnes, style peinture à l’huile"
image_embeds, negative_embeds = prior(
    prompt=prompt,
    guidance_scale=1.0
).to_tuple()

# Générer l’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")

Prompts multilingues

Kandinsky prend en charge plusieurs langues :

import torch
from diffusers import AutoPipelineForText2Image

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

# Anglais
image_en = pipe("Un renard roux dans une forêt enneigée").images[0]

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

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

# Allemand
image_de = pipe("Ein roter Fuchs im verschneiten Wald").images[0]

Toutes produisent des images similaires !

Fusion d’images

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")

# Deux prompts à fusionner
prompt1 = "Un chat"
prompt2 = "Un chien"

# Obtenir les embeddings pour les deux
embeds1, neg1 = prior(prompt1).to_tuple()
embeds2, neg2 = prior(prompt2).to_tuple()

# Fusionner les embeddings (50 % chacun)
mixed_embeds = 0.5 * embeds1 + 0.5 * embeds2
mixed_neg = 0.5 * neg1 + 0.5 * neg2

# Générer l’image fusionnée
image = decoder(
    image_embeds=mixed_embeds,
    negative_image_embeds=mixed_neg,
    height=768,
    width=768
).images[0]

image.save("cat_dog_mix.png")

Inpainting

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")

# Charger l’image et le masque
image = load_image("photo.png")
mask = load_image("mask.png")

# Inpainting
result = pipe(
    prompt="Une couronne dorée",
    image=image,
    mask_image=mask,
    num_inference_steps=50
).images[0]

result.save("inpainted.png")

Image à image

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="Une peinture numérique détaillée d’un château, art fantastique",
    image=init_image,
    strength=0.75,
    num_inference_steps=50
).images[0]

image.save("castle.png")

Génération par lots

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 = [
    "Un jardin japonais serein avec des fleurs de cerisier",
    "Une ville cyberpunk la nuit avec des néons",
    "Une bibliothèque ancienne remplie de livres magiques",
    "Un chalet douillet dans les montagnes pendant l’hiver"
]

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"Généré : {prompt[:30]}...")

    torch.cuda.empty_cache()

Interface 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="Décrivez votre image..."),
        gr.Textbox(label="Prompt négatif", value="faible qualité, flou, déformé"),
        gr.Slider(10, 100, value=50, step=5, label="Étapes"),
        gr.Slider(1, 20, value=4, step=0.5, label="Échelle de guidage"),
        gr.Slider(512, 1024, value=1024, step=64, label="Largeur"),
        gr.Slider(512, 1024, value=1024, step=64, label="Hauteur"),
        gr.Number(value=-1, label="Seed (-1 pour aléatoire)")
    ],
    outputs=gr.Image(label="Image générée"),
    title="Kandinsky 3 - Génération d’images",
    description="Générez des images avec des prompts multilingues. Fonctionne sur CLORE.AI."
)

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

Optimisation de la mémoire

import torch
from diffusers import AutoPipelineForText2Image

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

# Activer les optimisations mémoire
pipe.enable_model_cpu_offload()

# Ou pour une VRAM très faible
pipe.enable_sequential_cpu_offload()

# Activer le découpage de l'attention
pipe.enable_attention_slicing()

image = pipe(
    prompt="Un beau paysage",
    num_inference_steps=50
).images[0]

Performances

Modèle	Résolution	GPU	Temps
Kandinsky 3	1024x1024	RTX 3090	15 s
Kandinsky 3	1024x1024	RTX 4090	10 s
Kandinsky 2.2	768x768	RTX 3090	8 s
Kandinsky 2.2	768x768	RTX 4090	5 s

Dépannage

Mémoire insuffisante

Problème : OOM CUDA lors de la génération

Solutions :

• Activer le déchargement CPU

• Réduire la résolution

• Utiliser Kandinsky 2.2 au lieu de 3

• Activer le découpage de l’attention

pipe.enable_model_cpu_offload()
pipe.enable_attention_slicing()

Rendu du texte médiocre

Problème : Le texte dans les images semble incorrect

Solutions :

• Kandinsky a du mal à rendre le texte (comme la plupart des modèles de diffusion)

• Ajouter le texte en post-traitement

• Utiliser des prompts qui évitent le texte

Les couleurs semblent incorrectes

Problème : Les couleurs de l’image sont délavées ou trop saturées

Solutions :

• Ajuster l’échelle de guidage (essayez une plage de 3 à 6)

• Spécifier les préférences de couleur dans le prompt

• Post-traiter avec une correction des couleurs

Génération lente

Problème : La génération prend trop de temps

Solutions :

• Réduire les étapes d’inférence (30 suffisent souvent)

• Utiliser la précision fp16

• Utiliser Kandinsky 2.2 pour des résultats plus rapides

• Réduire la résolution pour les aperçus

Comparaison avec d’autres modèles

Fonctionnalité	Kandinsky 3	SDXL	FLUX
Multilingue	Excellente	Limité	Limité
Qualité de l’image	Élevée	Très élevée	La plus élevée
Vitesse	Moyen	Moyen	Lent
VRAM	12 Go	12 Go	24GB
Inpainting	Oui	Oui	Limité

Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 2024) :

GPU	Tarif horaire	Tarif journalier	Session de 4 heures
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 40 Go	~$0.17	~$4.00	~$0.70
A100 80 Go	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur. Consultez la place de marché CLORE.AI les tarifs actuels.

Étapes suivantes

• FLUX Generation - Images de la plus haute qualité

• Stable Diffusion - Option la plus populaire

• PixArt - Génération rapide

• ComfyUI - Flux de travail avancés