# PixArt

Générez des images rapidement avec PixArt-Alpha et PixArt-Sigma.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces Web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<adresse-proxy>`

## Qu'est-ce que PixArt ?

Les modèles PixArt offrent :

* 10x plus rapide que SDXL
* Images 1024px de haute qualité
* Rendu de texte performant
* Méthodes d'entraînement efficaces

## Variantes de modèle

| Modèle       | Qualité   | Vitesse | VRAM |
| ------------ | --------- | ------- | ---- |
| PixArt-Alpha | Excellent | Rapide  | 8 Go |
| PixArt-Sigma | Meilleur  | Moyen   | 12Go |

## Déploiement rapide

**Image Docker :**

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

**Ports :**

```
22/tcp
7860/http
```

**Commande :**

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

## Accéder à votre service

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

1. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

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

## Installation

```bash
pip install diffusers transformers accelerate
```

## PixArt-Alpha

### Génération basique

```python
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 chat astronaute flottant dans l'espace, la Terre en arrière-plan, photoréaliste"

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

image.save("output.png")
```

### Paramètres de génération

```python
image = pipe(
    prompt="un magnifique coucher de soleil sur des montagnes",
    negative_prompt="flou, faible qualité",
    num_inference_steps=20,      # Qualité (10-50)
    guidance_scale=4.5,          # Adhérence au prompt (3-7)
    height=1024,
    width=1024,
    generator=torch.Generator("cuda").manual_seed(42)
).images[0]
```

## PixArt-Sigma

Version de meilleure qualité :

```python
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="une photographie professionnelle d'une voiture de sport rouge",
    num_inference_steps=30,
    guidance_scale=4.5
).images[0]

image.save("sigma_output.png")
```

## Optimisation de la mémoire

### Pour 8 Go de VRAM

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

# Déchargement CPU
pipe.enable_model_cpu_offload()

# Déchargement CPU séquentiel (plus agressif)

# pipe.enable_sequential_cpu_offload()
```

### Activer le découpage VAE

```python
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()
```

## Génération par lot

```python
from diffusers import PixArtAlphaPipeline
import torch

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

prompts = [
    "une ville cyberpunk la nuit",
    "un jardin japonais paisible",
    "un château fantastique sur une falaise",
    "un récif corallien sous-marin"
]

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

## Résolutions différentes

```python

# Résolutions prises en charge
resolutions = [
    (512, 512),
    (768, 768),
    (1024, 1024),
    (1024, 512),   # Paysage
    (512, 1024),   # Portrait
    (768, 1024),
    (1024, 768),
]

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

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

## Rendu du texte

PixArt excelle pour le texte dans les images :

```python
prompt = """
Une affiche de film vintage avec le titre "COSMIC ADVENTURE" en lettres grasses,
présentant un vaisseau spatial et des planètes, style rétro des années 1950
"""

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

## Interface Gradio

```python
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 négatif"),
        gr.Slider(10, 50, value=20, step=1, label="Étapes"),
        gr.Slider(1, 10, value=4.5, step=0.5, label="Guidage"),
        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="Graine (-1 pour aléatoire)")
    ],
    outputs=gr.Image(label="Generated Image"),
    title="Générateur d'images PixArt"
)

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

## Serveur API

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

# Lancer : uvicorn server:app --host 0.0.0.0 --port 8000
```

## Comparaison des performances

| Modèle       | GPU      | Temps 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            |

## Paramètres de qualité

| Cas d'utilisation | Pas   | Guidage |
| ----------------- | ----- | ------- |
| Aperçu            | 10-15 | 4.0     |
| Standard          | 20    | 4.5     |
| Haute qualité     | 30-40 | 5.0     |

## Dépannage

### Mémoire insuffisante

```python

# Activer le déchargement
pipe.enable_model_cpu_offload()

# Ou utiliser une résolution plus petite
width, height = 768, 768
```

### Mauvaise qualité

* Augmenter les étapes (25-40)
* Ajuster l'échelle de guidage
* Prompts plus détaillés

### Génération lente

* Utiliser PixArt-Alpha (plus rapide)
* Réduire les étapes
* Baisser la résolution

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 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 40GB | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80GB | \~$0.25       | \~$6.00          | \~$1.00             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* Génération FLUX - Meilleure qualité
* Stable Diffusion WebUI - Plus de fonctionnalités
* [Guide ControlNet](https://docs.clore.ai/guides/guides_v2-fr/traitement-dimages/controlnet-advanced) - Ajouter un contrôle