PixArt

Generación rápida de imágenes con PixArt-Alpha y PixArt-Sigma

Genera imágenes rápidamente con PixArt-Alpha y PixArt-Sigma.

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

Alquilar en CLORE.AI

Visita CLORE.AI Marketplace
Filtrar por tipo de GPU, VRAM y precio
Elegir Bajo demanda (tarifa fija) o Spot (precio de puja)
Configura tu pedido:
- Selecciona imagen Docker
- Establece puertos (TCP para SSH, HTTP para interfaces web)
- Agrega variables de entorno si es necesario
- Introduce el comando de inicio
Selecciona pago: CLORE, BTC, o USDT/USDC
Crea el pedido y espera el despliegue

Accede a tu servidor

Encuentra los detalles de conexión en Mis Pedidos
Interfaces web: Usa la URL del puerto HTTP
SSH: ssh -p <port> root@<proxy-address>

¿Qué es PixArt?

Los modelos PixArt ofrecen:

10x más rápido que SDXL
Imágenes de alta calidad de 1024 px
Fuerte renderizado de texto
Métodos de entrenamiento eficientes

Variantes de modelo

Modelo

Calidad

Velocidad

VRAM

PixArt-Alpha

Genial

Rápido

8GB

PixArt-Sigma

Mejor

Medio

12GB

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
from diffusers import PixArtAlphaPipeline
import torch

pipe = PixArtAlphaPipeline.from_pretrained('PixArt-alpha/PixArt-XL-2-1024-MS', torch_dtype=torch.float16)
pipe.to('cuda')

def generate(prompt, steps):
    image = pipe(prompt, num_inference_steps=steps).images[0]
    return image

demo = gr.Interface(fn=generate, inputs=[gr.Textbox(), gr.Slider(10, 50, 20)], outputs=gr.Image(), title='PixArt')
demo.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:

Ir a Mis Pedidos página
Haz clic en tu pedido
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

PixArt-Alpha

Generación básica

from diffusers import PixArtAlphaPipeline
import torch

pipe = PixArtAlphaPipeline.from_pretrained(
    "PixArt-alpha/PixArt-XL-2-1024-MS",
    torch_dtype=torch.float16
)
pipe.to("cuda")

prompt = "Un astronauta gato flotando en el espacio, la Tierra de fondo, fotorrealista"

image = pipe(
    prompt=prompt,
    num_inference_steps=20,
    guidance_scale=4.5
).images[0]

image.save("output.png")

Parámetros de generación

image = pipe(
    prompt="un hermoso atardecer sobre montañas",
    negative_prompt="borroso, baja calidad",
    num_inference_steps=20,      # Calidad (10-50)
    guidance_scale=4.5,          # Adhesión al prompt (3-7)
    height=1024,
    width=1024,
    generator=torch.Generator("cuda").manual_seed(42)
).images[0]

PixArt-Sigma

Versión de mayor calidad:

from diffusers import PixArtSigmaPipeline
import torch

pipe = PixArtSigmaPipeline.from_pretrained(
    "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="una fotografía profesional de un coche deportivo rojo",
    num_inference_steps=30,
    guidance_scale=4.5
).images[0]

image.save("sigma_output.png")

Optimización de memoria

Para 8GB de VRAM

pipe = PixArtAlphaPipeline.from_pretrained(
    "PixArt-alpha/PixArt-XL-2-1024-MS",
    torch_dtype=torch.float16
)

# Desplazamiento a CPU
pipe.enable_model_cpu_offload()

# Desplazamiento secuencial a CPU (más agresivo)

# pipe.enable_sequential_cpu_offload()

Habilitar particionado de VAE

pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

Generación por lotes

from diffusers import PixArtAlphaPipeline
import torch

pipe = PixArtAlphaPipeline.from_pretrained(
    "PixArt-alpha/PixArt-XL-2-1024-MS",
    torch_dtype=torch.float16
).to("cuda")

prompts = [
    "una ciudad cyberpunk de noche",
    "un jardín japonés tranquilo",
    "un castillo fantástico en un acantilado",
    "un arrecife de coral submarino"
]

for i, prompt in enumerate(prompts):
    image = pipe(prompt, num_inference_steps=20).images[0]
    image.save(f"output_{i:03d}.png")
    print(f"Generado: {prompt[:50]}...")

Diferentes resoluciones


# Resoluciones compatibles
resolutions = [
    (512, 512),
    (768, 768),
    (1024, 1024),
    (1024, 512),   # Horizontal
    (512, 1024),   # Vertical
    (768, 1024),
    (1024, 768),
]

for w, h in resolutions:
    image = pipe(
        prompt="un paisaje hermoso",
        width=w,
        height=h,
        num_inference_steps=20
    ).images[0]

    image.save(f"output_{w}x{h}.png")

Renderizado de texto

PixArt sobresale en texto dentro de imágenes:

prompt = """
Un cartel de película vintage con el título "COSMIC ADVENTURE" en letras negritas,
con una nave espacial y planetas, estilo retro de los años 1950
"""

image = pipe(
    prompt=prompt,
    num_inference_steps=30,
    guidance_scale=5.0
).images[0]

Interfaz Gradio

import gradio as gr
from diffusers import PixArtAlphaPipeline
import torch

pipe = PixArtAlphaPipeline.from_pretrained(
    "PixArt-alpha/PixArt-XL-2-1024-MS",
    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", lines=3),
        gr.Textbox(label="Prompt negativo"),
        gr.Slider(10, 50, value=20, step=1, label="Pasos"),
        gr.Slider(1, 10, value=4.5, step=0.5, label="Guía"),
        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="Generador de imágenes PixArt"
)

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

Servidor API

from fastapi import FastAPI
from fastapi.responses import Response
from diffusers import PixArtAlphaPipeline
import torch
import io

app = FastAPI()

pipe = PixArtAlphaPipeline.from_pretrained(
    "PixArt-alpha/PixArt-XL-2-1024-MS",
    torch_dtype=torch.float16
).to("cuda")

@app.post("/generate")
async def generate(
    prompt: str,
    negative_prompt: str = "",
    steps: int = 20,
    guidance: float = 4.5,
    width: int = 1024,
    height: int = 1024
):
    image = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_inference_steps=steps,
        guidance_scale=guidance,
        width=width,
        height=height
    ).images[0]

    buffer = io.BytesIO()
    image.save(buffer, format="PNG")
    return Response(content=buffer.getvalue(), media_type="image/png")

# Ejecutar: uvicorn server:app --host 0.0.0.0 --port 8000

Comparación de rendimiento

Modelo

GPU

Tiempo 1024x1024

PixArt-Alpha

RTX 3090

~3s

PixArt-Sigma

RTX 3090

~5s

SDXL

RTX 3090

~15s

PixArt-Alpha

RTX 4090

~2s

PixArt-Sigma

RTX 4090

~3s

Ajustes de calidad

Caso de uso

Pasos

Guía

Vista previa

10-15

4.0

Estándar

4.5

Alta calidad

30-40

5.0

Solución de problemas

Memoria insuficiente


# Habilitar desplazamiento
pipe.enable_model_cpu_offload()

# O usar resolución más pequeña
width, height = 768, 768

Calidad pobre

Aumentar pasos (25-40)
Ajustar la escala de guía
Prompts más detallados

Generación lenta

Usar PixArt-Alpha (más rápido)
Reducir pasos
Reducir la resolución

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 y la demanda. Consulta CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

Usa Spot market para cargas de trabajo flexibles (a menudo 30-50% más barato)
Paga con CLORE tokens
Compara precios entre diferentes proveedores

Próximos pasos

Generación FLUX - Mejor calidad
Stable Diffusion WebUI - Más funciones
Guía de ControlNet - Añadir control

AnteriorFooocus SiguienteSDXL Turbo y LCM

Última actualización hace 1 mes

¿Te fue útil?

hashtagAlquilar en CLORE.AI

hashtagAccede a tu servidor

hashtag¿Qué es PixArt?

hashtagVariantes de modelo

hashtagDespliegue rápido

hashtagAccediendo a tu servicio

hashtagInstalación

hashtagPixArt-Alpha

hashtagGeneración básica

hashtagParámetros de generación

hashtagPixArt-Sigma

hashtagOptimización de memoria

hashtagPara 8GB de VRAM

hashtagHabilitar particionado de VAE

hashtagGeneración por lotes

hashtagDiferentes resoluciones

hashtagRenderizado de texto

hashtagInterfaz Gradio

hashtagServidor API

hashtagComparación de rendimiento

hashtagAjustes de calidad

hashtagSolución de problemas

hashtagMemoria insuficiente

hashtagCalidad pobre

hashtagGeneración lenta

hashtagEstimación de costos

hashtagPróximos pasos

Alquilar en CLORE.AI

Accede a tu servidor

¿Qué es PixArt?

Variantes de modelo

Despliegue rápido

Accediendo a tu servicio

Instalación

PixArt-Alpha

Generación básica

Parámetros de generación

PixArt-Sigma

Optimización de memoria

Para 8GB de VRAM

Habilitar particionado de VAE

Generación por lotes

Diferentes resoluciones

Renderizado de texto

Interfaz Gradio

Servidor API

Comparación de rendimiento

Ajustes de calidad

Solución de problemas

Memoria insuficiente

Calidad pobre

Generación lenta

Estimación de costos

Próximos pasos