Kandinsky

Genera imágenes con el modelo multilingüe Kandinsky en Clore.ai

Genera imágenes con una potente comprensión multilingüe del texto.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

¿Qué es Kandinsky?

Kandinsky es un modelo de generación de imágenes desarrollado por Sber AI:

• Fuerte comprensión multilingüe del texto

• Generación de imágenes de alta calidad

• Mezcla e interpolación de imágenes

• Soporte para inpainting y outpainting

• Pesos de código abierto

Recursos

• GitHub: ai-forever/Kandinsky-3

• HuggingFace: kandinsky-community

• Artículo: Documento de Kandinsky

Versiones del modelo

Versión	Resolución	Calidad	Velocidad
Kandinsky 2.1	768x768	Bueno	Rápido
Kandinsky 2.2	1024x1024	Mejor	Medio
Kandinsky 3	1024x1024	Mejor	Más lento

Requisitos de hardware

Modelo	VRAM	GPU recomendada
Kandinsky 2.2	8GB	RTX 3070
Kandinsky 3	12GB	RTX 3090
Kandinsky 3 (alta resolución)	16GB	RTX 4090

Despliegue rápido

Imagen Docker:

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

Puertos:

22/tcp
7860/http

Comando:

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

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis Pedidos:

1. Ir a Mis Pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Instalación

pip install diffusers transformers accelerate torch

Uso básico

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 gato astronauta flotando en el espacio, arte digital, colores vibrantes",
    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

# Cargar prior (codificador de texto)
prior = KandinskyV22PriorPipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-prior",
    torch_dtype=torch.float16
).to("cuda")

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

# Generar incrustaciones de imagen
prompt = "Un hermoso atardecer sobre montañas, estilo pintura al óleo"
image_embeds, negative_embeds = prior(
    prompt=prompt,
    guidance_scale=1.0
).to_tuple()

# Generar imagen
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 multilingües

Kandinsky admite múltiples idiomas:

import torch
from diffusers import AutoPipelineForText2Image

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

# Inglés
image_en = pipe("A red fox in a snowy forest").images[0]

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

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

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

# ¡Todos producen imágenes similares!

Mezcla de imágenes

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

# Dos prompts para mezclar
prompt1 = "Un gato"
prompt2 = "Un perro"

# Obtener incrustaciones para ambos
embeds1, neg1 = prior(prompt1).to_tuple()
embeds2, neg2 = prior(prompt2).to_tuple()

# Mezclar incrustaciones (50% cada una)
mixed_embeds = 0.5 * embeds1 + 0.5 * embeds2
mixed_neg = 0.5 * neg1 + 0.5 * neg2

# Generar imagen mezclada
image = decoder(
    image_embeds=mixed_embeds,
    negative_image_embeds=mixed_neg,
    height=768,
    width=768
).images[0]

image.save("cat_dog_mix.png")

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

# Cargar imagen y máscara
image = load_image("photo.png")
mask = load_image("mask.png")

# Inpaint
result = pipe(
    prompt="Una corona dorada",
    image=image,
    mask_image=mask,
    num_inference_steps=50
).images[0]

result.save("inpainted.png")

Imagen a imagen

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="Una pintura digital detallada de un castillo, arte fantástico",
    image=init_image,
    strength=0.75,
    num_inference_steps=50
).images[0]

image.save("castle.png")

Generación por lotes

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 sereno jardín japonés con flores de cerezo",
    "Una ciudad cyberpunk de noche con luces neon",
    "Una biblioteca antigua llena de libros mágicos",
    "Una cabaña acogedora en las montañas durante el invierno"
]

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

Interfaz 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 tu imagen..."),
        gr.Textbox(label="Negative Prompt", value="baja calidad, borroso, distorsionado"),
        gr.Slider(10, 100, value=50, step=5, label="Pasos"),
        gr.Slider(1, 20, value=4, step=0.5, label="Escala de guidance"),
        gr.Slider(512, 1024, value=1024, step=64, label="Ancho"),
        gr.Slider(512, 1024, value=1024, step=64, label="Alto"),
        gr.Number(value=-1, label="Semilla (-1 para aleatorio)")
    ],
    outputs=gr.Image(label="Imagen generada"),
    title="Kandinsky 3 - Generación de imágenes",
    description="Genera imágenes con prompts multilingües. Ejecutándose en CLORE.AI."
)

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

Optimización de memoria

import torch
from diffusers import AutoPipelineForText2Image

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

# Habilitar optimizaciones de memoria
pipe.enable_model_cpu_offload()

# O para VRAM muy baja
pipe.enable_sequential_cpu_offload()

# Habilitar particionado de atención
pipe.enable_attention_slicing()

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

Rendimiento

Modelo	Resolución	GPU	Tiempo
Kandinsky 3	1024x1024	RTX 3090	15 s
Kandinsky 3	1024x1024	RTX 4090	10s
Kandinsky 2.2	768x768	RTX 3090	8s
Kandinsky 2.2	768x768	RTX 4090	5s

Solución de problemas

Memoria insuficiente

Problema: OOM de CUDA al generar

Soluciones:

• Habilitar descarga a CPU

• Reducir resolución

• Usar Kandinsky 2.2 en lugar de 3

• Habilitar segmentación de atención

pipe.enable_model_cpu_offload()
pipe.enable_attention_slicing()

Renderizado de texto deficiente

Problema: El texto en las imágenes se ve incorrecto

Soluciones:

• Kandinsky tiene dificultades con el renderizado de texto (como la mayoría de los modelos de difusión)

• Agregar texto en postprocesado

• Usar prompts que eviten texto

Los colores se ven mal

Problema: Los colores de la imagen están lavados o sobresaturados

Soluciones:

• Ajustar la escala de guidance (probar rango 3-6)

• Especificar preferencias de color en el prompt

• Postprocesar con corrección de color

Generación lenta

Problema: Tarda demasiado en generar

Soluciones:

• Reducir pasos de inferencia (30 suele ser suficiente)

• Usar precisión fp16

• Usar Kandinsky 2.2 para resultados más rápidos

• Reducir resolución para vistas previas

Comparación con otros modelos

Función	Kandinsky 3	SDXL	FLUX
Multilingüe	Excelente	Limitado	Limitado
Calidad de imagen	Alto	Muy alta	La más alta
Velocidad	Medio	Medio	Lento
VRAM	12GB	12GB	24GB
Rellenado (Inpainting)	Sí	Sí	Limitado

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

GPU	Tarifa por hora	Tarifa diaria	Sesión de 4 horas
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

Los precios varían según el proveedor. Consulta CLORE.AI Marketplace para las tarifas actuales.

Próximos pasos

• FLUX Generation - Imágenes de la más alta calidad

• Stable Diffusion - Opción más popular

• PixArt - Generación rápida

• ComfyUI - Flujos de trabajo avanzados