Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /fr /api /pipelines /bria_fibo2.md
mishig
3 days ago
preview code
download
raw
23.7 kB
# Bria Fibo 2.0

Fibo 2.0 est un transformer flow-matching de 8,1 milliards de paramètres de [Bria](https://huggingface.co/briaai) qui génère des images à partir de légendes JSON structurées. Son encodeur de texte est [Qwen3-VL](https://huggingface.co/Qwen/Qwen3-VL-4B-Instruct) : un Perceiver condense les états cachés de Qwen3-VL en jetons de résumé qui rejoignent les jetons d'image dans un seul flux, et cinq des blocs du transformer lisent également Qwen3-VL directement via une attention croisée à porte.

Il y a deux points de contrôle :

- [`briaai/Fibo-2.0-dev`](https://huggingface.co/briaai/Fibo-2.0-dev), le modèle complet pour la génération d’images à partir de texte et l’édition, avec guidance sans classifieur. Les valeurs par défaut du pipeline, 30 étapes avec un guidance de 5, correspondent à ce point de contrôle.
- [`briaai/Fibo-2.0-edit-turbo`](https://huggingface.co/briaai/Fibo-2.0-edit-turbo), distillé pour l'édition en 4 étapes sans guidage (`guidance_scale=1.0`).

Avec le guidage activé, le prompt négatif par défaut est la légende nulle avec laquelle le modèle a été entraîné : la légende structurée dont toutes les valeurs sont laissées vides.

## Génération

Fibo 2.0 est entraîné sur des légendes JSON structurées et ne fonctionnera pas bien avec du texte libre. Passez la légende sous forme de chaîne JSON :

```py
import json
import torch
from diffusers import BriaFibo2Pipeline
pipe = BriaFibo2Pipeline.from_pretrained("briaai/Fibo-2.0-dev", dtype=torch.bfloat16).to("cuda")
caption = {
    "short_description": "A red vintage bicycle leaning against a whitewashed wall on a narrow Mediterranean street.",
    "objects": [
        {
            "description": "A red vintage bicycle with a wicker basket of lemons on its handlebars.",
            "location": "center",
            "relative_size": "large within frame",
        }
    ],
    "background_setting": "A whitewashed wall with a blue wooden door and potted red geraniums.",
    "lighting": {"conditions": "bright morning sun", "direction": "from the right", "shadows": "long and crisp"},
    "aesthetics": {"composition": "centered", "color_scheme": "red, white and blue", "mood_atmosphere": "calm"},
    "photographic_characteristics": {"depth_of_field": "deep", "focus": "sharp on the bicycle", "camera_angle": "eye level"},
    "style_medium": "photograph",
    "context": "A travel photograph.",
    "artistic_style": "realistic",
}
image = pipe(json.dumps(caption)).images[0]
image.save("bicycle.png")
```

Le pipeline nettoie la légende de la même manière que lors de l’entraînement : il supprime les valeurs vides ainsi que les champs `aesthetic_score` et `preference_score`, qui n’étaient présents dans aucune légende d’entraînement, et sérialise la légende de manière compacte. Deux formes courtes ont également été entraînées et sont conservées telles quelles :

```py
# The caption's short description alone, as plain text
image = pipe("A red vintage bicycle leaning against a whitewashed wall on a narrow Mediterranean street.").images[0]
# Exactly a "short_description" and a "text_render" list. The list is kept even when it's empty, to say the image
# has no text
caption = {"short_description": "A bakery storefront at dawn with a painted sign.", "text_render": [{"text": "FRESH BREAD"}]}
image = pipe(json.dumps(caption)).images[0]
```

Pour convertir un texte libre en légende structurée, consultez les modèles prompt-to-JSON sur la page [Bria Fibo](https://huggingface.co/briaai/FIBO).

## Édition

Le même pipeline modifie les images. Passez l'image en tant que `image` et l'instruction de modification en tant que prompt :

```py
import torch
from diffusers import BriaFibo2Pipeline
from diffusers.utils import load_image
pipe = BriaFibo2Pipeline.from_pretrained("briaai/Fibo-2.0-dev", dtype=torch.bfloat16).to("cuda")
image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png"
)
edited = pipe("Make the background a snowy forest", image=image).images[0]
edited.save("pikachu_snow.png")
```

Pour des modifications plus rapides, chargez le point de contrôle turbo et désactivez le guidage :

```py
import torch
from diffusers import BriaFibo2Pipeline
from diffusers.utils import load_image
pipe = BriaFibo2Pipeline.from_pretrained("briaai/Fibo-2.0-edit-turbo", dtype=torch.bfloat16).to("cuda")
image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png"
)
edited = pipe("Make the background a snowy forest", image=image, num_inference_steps=4, guidance_scale=1.0).images[0]
edited.save("pikachu_snow.png")
```

Les exemples ci-dessous reprennent l’un ou l’autre, avec son `pipe` et son `image`. Avec le checkpoint turbo, passez `num_inference_steps=4` et `guidance_scale=1.0` à chaque appel.

### Le prompt de modification

Le prompt peut également être un objet JSON avec une clé `"edit_instruction"` et une légende du résultat, dans l'une des formes avec lesquelles Fibo 2.0 a été entraîné à effectuer des modifications. Le pipeline le convertit en le prompt avec lequel Fibo 2.0 a été entraîné à effectuer des modifications.

Légende complète : les clés de la légende, à côté de `"edit_instruction"`, telles que les modèles prompt-vers-JSON de Bria les écrivent pour les modifications. Le pipeline supprime les valeurs vides ainsi que les champs `aesthetic_score` et `preference_score`, que l'entraînement a retirés de toutes les légendes.

```py
import json
prompt = {
    "short_description": "A crocheted yellow Pikachu doll sitting in a snowy pine forest.",
    "objects": [{"description": "A crocheted yellow Pikachu doll with red cheeks.", "location": "center"}],
    "background_setting": "A snowy pine forest with falling snow.",
    "edit_instruction": "Make the background a snowy forest",
}
edited = pipe(json.dumps(prompt), image=image).images[0]
```

Une brève description : une chaîne de caractères dans la clé `"structured_caption"`.

```py
prompt = {
    "structured_caption": "A crocheted yellow Pikachu doll sitting in a snowy pine forest.",
    "edit_instruction": "Make the background a snowy forest",
}
edited = pipe(json.dumps(prompt), image=image).images[0]
```

Une brève description et son texte : exactement une `"short_description"` et une liste `"text_render"`. La liste est conservée même lorsqu'elle est vide, ce qui indique à Fibo 2.0 que le résultat ne contient pas de texte. Une clé `"structured_caption"` peut contenir ce formulaire, ou une légende complète.

```py
prompt = {
    "short_description": "A crocheted yellow Pikachu doll holding a small wooden sign.",
    "text_render": [{"text": "HELLO"}],
    "edit_instruction": "Give the doll a small wooden sign that reads HELLO",
}
edited = pipe(json.dumps(prompt), image=image).images[0]
```

### Plusieurs images

Jusqu'à 5 images peuvent être éditées ensemble, par exemple pour placer un objet d'une image dans une autre. L'instruction les désigne dans l'ordre sous la forme `<image_1>`, `<image_2>`, et ainsi de suite.

```py
cat = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cat.png")
edited = pipe("Put the cat from <image_2> next to the doll in <image_1>", image=[image, cat]).images[0]
```

### Taille de la sortie

À moins que `height` et `width` ne soient fournis, le résultat adopte la taille pour laquelle Fibo 2.0 a été entraîné, correspondant au ratio d’aspect de la première image, soit environ un mégapixel. Une image unique est recadrée à la taille du résultat. Plusieurs images sont chacune recadrées à la taille d’entraînement correspondant à leur propre ratio d’aspect.

```py
edited = pipe("Make the background a snowy forest", image=image, width=1424, height=800).images[0]
```

### Modifications masquées

`mask` marque la région d’une image unique à régénérer, en blanc sur fond noir, aux dimensions de l’image. Fibo 2.0 a été entraîné sur des modifications dont l’image présente cette région grisée, et le pipeline la grise de la même manière avant que l’image soit encodée : gris plat (128, 128, 128), via le masque rendu binaire à 128.

```py
from PIL import Image, ImageDraw
mask = Image.new("L", image.size, 0)
ImageDraw.Draw(mask).rectangle((image.width // 2, 0, image.width, image.height // 2), fill=255)
edited = pipe("Add a red balloon floating in the sky", image=image, mask=mask).images[0]
```

## Texte dans les images

Lorsque la légende demande du texte, dans ses entrées `text_render`, Fibo 2.0 a tendance à le rendre mieux si Qwen3-VL voit également chaque texte dessiné séparément. Le pipeline dessine ces images par défaut, comme c’était le cas lors de l’entraînement, et ils peuvent être désactivés. Pour une légende contenant du texte, comme celle de la boulangerie ci-dessus :

```py
prompt = json.dumps(caption)
image = pipe(prompt, render_text_images=False).images[0]
```

L'entraînement a montré à Fibo 2.0 ces images pour certaines légendes avec du texte et pas pour d'autres, donc cela fonctionne dans les deux cas.

- Chaque entrée `text_render` qui possède `text` reçoit une image : le texte sur une seule ligne, en noir sur fond blanc, avec la police intégrée de Pillow, en taille 20. Un texte de plus de 256 caractères est découpé en lignes de 256.
- Les caractères manquants dans la police sont dessinés avec la première police de `fonts` qui les contient. L’entraînement a utilisé Aileron, puis DejaVu Sans, qui se trouvent dans le dossier `fonts` de [`briaai/Fibo-2.0-dev`](https://huggingface.co/briaai/Fibo-2.0-dev). Sans `fonts`, ces caractères sont dessinés comme le ferait la police intégrée de Pillow, et le pipeline émet un avertissement.
- Le pipeline marque chaque entrée avec un champ `image_tokens` pour son image, et Qwen3-VL voit les images après les images à modifier.
- Une génération effectue ses premières étapes, tant que le niveau de bruit est supérieur à `pipe.text_images_max_noise_level` (0.9), sur la légende sans les images. Une édition les utilise à chaque étape.
- Une légende sans texte ne génère aucune image, tout comme une description courte, comme lors de l'entraînement.

Pour les dessiner avec les polices utilisées pour l'entraînement :

```py
from huggingface_hub import hf_hub_download
fonts = [
    hf_hub_download("briaai/Fibo-2.0-dev", name, subfolder="fonts")
    for name in ("Aileron-Regular.otf", "DejaVuSans.ttf")
]
image = pipe(prompt, fonts=fonts).images[0]
```

Pour dessiner les images vous-même, passez-les en tant que `text_images`, une par entrée `text_render` qui possède `text`, dans l'ordre, pour un prompt unique. Elles prennent le pas sur celles du pipeline. Les images dessinées différemment de l'entraînement sont hors distribution.

## Backends d'attention

Le transformateur fonctionne avec l'un des [backends d'attention](../../optimization/attention_backends) de diffusers, par exemple FlashAttention-3 sur des GPU Hopper tels que le H100 :

```py
pipe.transformer.set_attention_backend("_flash_3_varlen_hub")
```

`_flash_3_hub` fonctionne également pour un seul prompt, mais il n’accepte pas de masques, il ne peut donc pas exécuter un lot de prompts de longueurs différentes (voir ci-dessous).

## Batching

Plusieurs prompts peuvent être générés en un seul appel. Les prompts de longueurs différentes sont complétés (padding), et ce padding est masqué dans chaque couche d'attention, si bien qu'un tel lot nécessite un backend d'attention qui gère un masque : le backend par défaut, ou un backend varlen tel que `flash_varlen`. En float32, un lot reproduit les images des appels individuels ; en bfloat16, les noyaux d'attention diffèrent entre les entrées avec et sans padding, de sorte que les images générées en lot peuvent différer des appels unitaires dans les détails fins.

## BriaFibo2Pipeline[[diffusers.BriaFibo2Pipeline]]

#### diffusers.BriaFibo2Pipeline[[diffusers.BriaFibo2Pipeline]]

```python
diffusers.BriaFibo2Pipeline(transformer: BriaFibo2Transformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLFlux2, text_encoder: Qwen3VLForConditionalGeneration, processor: Qwen3VLProcessor)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/bria_fibo2/pipeline_bria_fibo2.py#L171)

**Paramètres :**

transformer ([BriaFibo2Transformer2DModel](/docs/diffusers/main/fr/api/models/transformer_bria_fibo2#diffusers.BriaFibo2Transformer2DModel)) : le transformer qui débruite les latents de l'image.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Planificateur utilisé avec `transformer` pour débruyer les latents.

vae (`AutoencoderKLFlux2`) : Auto-encodeur variationnel qui mappe les images vers des latents et inversement.

text_encoder (`Qwen3VLForConditionalGeneration`) : Qwen3-VL. Ses états cachés conditionnent le transformeur.
processor (`Qwen3VLProcessor`) : Convertit le prompt et les images à modifier en entrées Qwen3-VL.
Pipeline pour la génération d'images à partir de texte et l'édition d'images avec Fibo 2.0.
#### __appel__[[diffusers.BriaFibo2Pipeline.__call__]]
```python
__call__(prompt: str | list[str] | None = None, image: PIL.Image.Image | list[PIL.Image.Image] | None = None, mask: PIL.Image.Image | None = None, text_images: list[PIL.Image.Image] | None = None, render_text_images: bool = True, fonts: list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 30, guidance_scale: float = 5.0, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, output_type: str = 'pil', return_dict: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int, dict], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'])
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/bria_fibo2/pipeline_bria_fibo2.py#L571)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : Le prompt pour guider la génération d’image, généralement un prompt JSON structuré, nettoyé selon les légendes nettoyées lors de l’entraînement de Fibo 2.0 : les valeurs vides ainsi que les champs `aesthetic_score` et `preference_score` sont supprimés, et le résultat est sérialisé de manière compacte. Avec `image`, l’instruction d’édition, ou un objet JSON avec une clé `"edit_instruction"` et la légende du résultat : ses autres clés, ou une clé `"structured_caption"` contenant la légende ou une brève description.
image (`PIL.Image.Image` ou `list[PIL.Image.Image]`, *facultatif*) : L'image à modifier, ou jusqu'à 5 images à modifier ensemble, auxquelles l'instruction peut faire référence sous la forme `<image_1>`, `<image_2>`, etc. En l'absence de `image`, le pipeline génère une image à partir du prompt.
mask (`PIL.Image.Image`, *facultatif*) : La région de `image` à régénérer, en blanc sur fond noir, lors de l'édition d'une image unique. Comme lors de l'entraînement, la région est grisée avant l'encodage de l'image, via le masque rendu binaire à 128.
text_images (`list[PIL.Image.Image]`, *facultatif*) : Images du texte demandé par la légende, une par entrée `text_render` contenant `text`, dans l'ordre : le texte de chaque entrée est dessiné séparément, comme le fait `render_text_images`. Qwen3-VL les consulte avec le prompt, chacune étant marquée dans son entrée de légende, ce qui aide Fibo 2.0 à rendre le texte. Nécessite `prompt` sous forme d'une légende JSON unique et prend le pas sur `render_text_images`. Une génération exécute ses premières étapes, tant que le niveau de bruit est supérieur à `text_images_max_noise_level` (0,9), sans elles ; une édition les utilise à chaque étape.

render_text_images (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut dessiner les `text_images` de chaque légende, de la même manière que lors de l'entraînement de Fibo 2.0 : chaque texte sur une ligne, en noir sur fond blanc, avec la police intégrée de Pillow en taille 20, et les caractères manquants dans cette police sont pris dans la première des `fonts` qui les contient. Une légende sans texte, et un prompt sans légende JSON, comme une courte description, ne reçoivent pas d'images, comme lors de l'entraînement.

fonts (`list[str]`, *facultatif*) : Chemins des polices à utiliser pour dessiner les caractères de `text_images` que la police intégrée de Pillow ne possède pas, dans l'ordre. L'entraînement les a dessinés avec Aileron, puis DejaVu Sans, qui se trouvent dans le dossier `fonts` de `briaai/Fibo-2.0-dev`. Sans elles, ces caractères sont dessinés comme le ferait la police intégrée de Pillow.

height (`int`, *facultatif*) : La hauteur en pixels de l'image générée. Doit être divisible par 16. Valeur par défaut : 1024, ou, lors d'une édition, la taille pour laquelle Fibo 2.0 a été entraîné pour le ratio d'aspect de la première image, soit environ un mégapixel.

width (`int`, *facultatif*) : La largeur en pixels de l'image générée. Doit être divisible par 16. Valeur par défaut identique à `height`.

num_inference_steps (`int`, *facultatif*, valeur par défaut 30) : Le nombre d'étapes de débruitage.

guidance_scale (`float`, *facultatif*, valeur par défaut 5.0) : Échelle du guidage sans classifieur. Les valeurs supérieures à 1 exécutent le prompt négatif comme un second passage à chaque étape, et 1.0 désactive le guidage.
negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt à éviter lorsque le guidage est activé. Par défaut, la légende nulle avec laquelle Fibo 2.0 a été entraîné : la légende structurée avec toutes les valeurs vides.

num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.
generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Générateur(s) utilisé(s) pour tirer le bruit initial, pour une génération déterministe.
latents (`torch.Tensor`, *facultatif*) : Bruit de départ pré-généré de forme `(batch_size, 32, height // 8, width // 8)`.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte précalculées issues de `encode_prompt`, utilisées à la place de `prompt`.

prompt_embeds_mask (`torch.Tensor`, *facultatif*) : Le masque `encode_prompt` renvoyé avec `prompt_embeds`. Nécessaire lorsqu'ils sont complétés (padded).

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte précalculées du prompt négatif, utilisées à la place de `negative_prompt`.

negative_prompt_embeds_mask (`torch.Tensor`, *facultatif*) : Le masque `encode_prompt` renvoyé avec `negative_prompt_embeds`. Nécessaire lorsqu'ils sont complétés (padded).

output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie : `"pil"`, `"np"`, `"pt"` ou `"latent"`.
return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `BriaFibo2PipelineOutput` plutôt qu'un simple tuple.

callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage en tant que `callback_on_step_end(self, step, timestep, callback_kwargs)`.
callback_on_step_end_tensor_inputs (`list[str]`, *facultatif*, par défaut `["latents"]`) : Les tenseurs passés à `callback_on_step_end` dans `callback_kwargs`.

**Retourne :** `BriaFibo2PipelineOutput` ou `tuple`

les images générées.

Fonction appelée lors de l'appel du pipeline pour la génération.

Exemples :
```py
>>> import json
>>> import torch
>>> from diffusers import BriaFibo2Pipeline
>>> from diffusers.utils import load_image
>>> # Fibo 2.0 reads structured JSON captions, serialized compactly the way it was trained
>>> caption = {
...     "short_description": "A red bicycle leaning against a white brick wall on a sunny morning.",
...     "objects": [{"description": "a red city bicycle with a wicker basket", "location": "center"}],
...     "background_setting": "a white brick wall with a green door",
...     "lighting": {"conditions": "bright morning sun", "direction": "from the right"},
...     "style_medium": "photograph",
... }
>>> prompt = json.dumps(caption, separators=(",", ":"), ensure_ascii=False)
>>> # 30 steps with guidance 5, the defaults
>>> pipe = BriaFibo2Pipeline.from_pretrained("briaai/Fibo-2.0-dev", dtype=torch.bfloat16).to("cuda")
>>> image = pipe(prompt).images[0]
>>> image.save("fibo2.png")
>>> # editing: pass the image, and the instruction as the prompt
>>> image = load_image(
...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png"
... )
>>> edited = pipe("Make the background a snowy forest", image=image).images[0]
>>> edited.save("fibo2_edit.png")
```

#### encode_prompt[[diffusers.BriaFibo2Pipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], image: list[PIL.Image.Image] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, text_images: list[PIL.Image.Image] | list[list[PIL.Image.Image]] | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/bria_fibo2/pipeline_bria_fibo2.py#L351)

**Paramètres :**

prompt (`str` ou `list[str]`) : Le prompt ou les prompts à encoder. Avec `image`, chaque prompt est une instruction de modification, ou un objet JSON avec une clé `"edit_instruction"` et la légende du résultat : ses autres clés, ou une clé `"structured_caption"` contenant la légende ou une brève description. Un prompt de génération est encodé tel quel : `__call__` place d'abord une légende JSON dans le format avec lequel Fibo 2.0 a été entraîné.

image (`list[PIL.Image.Image]`, *facultatif*) : Les images à modifier, telles que Qwen3-VL les perçoit. Chaque invite modifie toutes les images.

device (`torch.device`, *facultatif*) : L'appareil sur lequel placer les embeddings.

num_images_per_prompt (`int`, par défaut 1) : Nombre d'images à générer par invite.
prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte précalculées de forme `(batch_size, 6, text_len, 7680)`, utilisées à la place de `prompt`.

prompt_embeds_mask (`torch.Tensor`, *facultatif*) : Masque booléen des jetons réels dans `prompt_embeds`, de forme `(batch_size, text_len)`.

text_images (`list[PIL.Image.Image]` ou `list[list[PIL.Image.Image]]`, *facultatif*) : Images du texte de la légende, une par entrée `text_render` contenant `text`, dans l'ordre, ou une liste de celles-ci par invite. Chaque entrée reçoit le marqueur visuel de son image, et Qwen3-VL voit les images après celles destinées à l'édition.

**Retourne :**

Les embeddings de texte, ainsi que leur masque, ou `None` si aucun prompt n'a été complété.
Xet Storage Details

Size:: 23.7 kB
Xet hash:: c2e2aff2e1e2beb52f19ed69927d64ca431132c478486f0683464c90529f08f1
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.