# Ovis-Image

![concepts](https://github.com/AIDC-AI/Ovis-Image/blob/main/docs/imgs/ovis_image_case.png)

Ovis-Image est un modèle de génération d'images à partir de texte de 7B, spécifiquement optimisé pour un rendu de texte de haute qualité, et conçu pour fonctionner efficacement dans des contraintes de calcul strictes.

[Rapport technique Ovis-Image](https://arxiv.org/abs/2511.22982) d’Alibaba Group, par Guo-Hua Wang, Liangfu Cao, Tianyu Cui, Minghao Fu, Xiaohao Chen, Pengxin Zhan, Jianshan Zhao, Lan Li, Bowen Fu, Jiaqi Liu, Qing-Guo Chen.

L'abstract de l'article est :

*Nous présentons Ovis-Image, un modèle texte-vers-image de 7B spécifiquement optimisé pour le rendu de texte de haute qualité, conçu pour fonctionner efficacement sous des contraintes de calcul strictes. Construit sur la base de notre précédent cadre Ovis-U1, Ovis-Image intègre un décodeur visuel basé sur la diffusion avec le socle multimodal plus puissant Ovis 2.5, en exploitant un pipeline d'entraînement centré sur le texte qui combine un pré-entraînement à grande échelle avec des raffinements post-entraînement soigneusement adaptés. Malgré son architecture compacte, Ovis-Image atteint des performances de rendu de texte comparables à celles de modèles ouverts nettement plus grands, tels que Qwen-Image, et se rapproche des systèmes propriétaires comme Seedream et GPT4o. Surtout, le modèle reste déployable sur un seul GPU haut de gamme avec une mémoire modérée, réduisant l'écart entre le rendu de texte de pointe et le déploiement pratique. Nos résultats indiquent que la combinaison d'un socle multimodal puissant et d'une recette d'entraînement soigneusement conçue, axée sur le texte, est suffisante pour obtenir un rendu de texte bilingue fiable sans recourir à des modèles surdimensionnés ou propriétaires.*

**Points forts** :

*   **Rendu de texte performant à l'échelle compacte de 7B** : Ovis-Image est un modèle texte-vers-image de 7B qui offre une qualité de rendu du texte comparable à celle de systèmes beaucoup plus grands de la classe 20B, tels que Qwen-Image, et qui rivalise avec les modèles propriétaires de pointe comme GPT4o dans les scénarios centrés sur le texte, tout en restant suffisamment léger pour s'exécuter sur des matériels largement accessibles.
*   **Fidélité élevée sur les prompts riches en texte et sensibles à la mise en page** : Le modèle excelle sur les prompts qui exigent un alignement précis entre le contenu linguistique et la typographie rendue (par exemple, affiches, bannières, logos, maquettes d'interface utilisateur, infographies), produisant un texte lisible, correctement orthographié et sémantiquement cohérent à travers diverses polices, tailles et rapports d'aspect, sans compromettre la qualité visuelle globale.
*   **Efficacité et déploiabilité** : Avec son budget de 7 milliards de paramètres et son architecture optimisée, Ovis-Image tient sur un seul GPU haut de gamme avec une mémoire modérée, prend en charge une utilisation interactive à faible latence et s'adapte au service de production par lots, apportant un rendu de texte proche de l'état de l'art à des applications où les modèles de plusieurs dizaines de milliards de paramètres sont irréalisables.

Ce pipeline a été contribué par l'équipe Ovis-Image. Le code source original est disponible [ici](https://github.com/AIDC-AI/Ovis-Image).

Modèles disponibles :

| Modèle | dtype recommandé |
|:-----:|:-----------------:|
| [`AIDC-AI/Ovis-Image-7B`](https://huggingface.co/AIDC-AI/Ovis-Image-7B) | `torch.bfloat16` |

Consultez cette [collection](https://huggingface.co/collections/AIDC-AI/ovis-image) pour plus d'informations.

## OvisImagePipeline[[diffusers.OvisImagePipeline]]

#### diffusers.OvisImagePipeline[[diffusers.OvisImagePipeline]]

```python
diffusers.OvisImagePipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: Qwen3Model, tokenizer: Qwen2Tokenizer, transformer: OvisImageTransformer2DModel)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ovis_image/pipeline_ovis_image.py#L129)

**Paramètres :**

transformer ([OvisImageTransformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/ovisimage_transformer2d#diffusers.OvisImageTransformer2DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.

text_encoder (`Qwen3Model`) : Encodeur de texte de la classe [Qwen3Model](https://huggingface.co/docs/transformers/en/model_doc/qwen3#transformers.Qwen3Model).

tokenizer (`Qwen2TokenizerFast`) : Tokenizer de la classe [Qwen2TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2TokenizerFast).

Le pipeline Ovis-Image pour la génération d'images à partir de texte.

Référence : https://github.com/AIDC-AI/Ovis-Image

#### __appel__[[diffusers.OvisImagePipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = '', guidance_scale: float = 5.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 256)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ovis_image/pipeline_ovis_image.py#L457)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passer `prompt_embeds` à la place.

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` n’est pas supérieur à `1`).

guidance_scale (`float`, *facultatif*, valeur par défaut 1.0) : la guidance sans classifieur (échelle de guidance) est activée lorsque `guidance_scale` > 1 et que `negative_prompt` est fourni.

height (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.

width (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La largeur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.

num_inference_steps (`int`, *facultatif*, valeur par défaut 50) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.

sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.

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*) : Un ou une liste de [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.

latents (`torch.FloatTensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération d'images. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.

prompt_embeds (`torch.FloatTensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

negative_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Incrustations de texte négatif pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* le pondération des prompts. Si non fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`.

output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.

return_dict (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut retourner un `~pipelines.flux.FluxPipelineOutput` plutôt qu'un simple tuple.

joint_attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`List`, *facultatif*) : La liste des entrées de tenseurs pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.

max_sequence_length (`int` par défaut 512) : Longueur maximale de la séquence à utiliser avec le `prompt`.

**Retourne :** [OvisImagePipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/ovis_image#diffusers.pipelines.ovis_image.OvisImagePipelineOutput) ou `tuple`

[OvisImagePipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/ovis_image#diffusers.pipelines.ovis_image.OvisImagePipelineOutput) si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées.

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

Exemples :
```py
>>> import torch
>>> from diffusers import OvisImagePipeline

>>> pipe = OvisImagePipeline.from_pretrained("AIDC-AI/Ovis-Image-7B", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = 'A creative 3D artistic render where the text "OVIS-IMAGE" is written in a bold, expressive handwritten brush style using thick, wet oil paint. The paint is a mix of vibrant rainbow colors (red, blue, yellow) swirling together like toothpaste or impasto art. You can see the ridges of the brush bristles and the glossy, wet texture of the paint. The background is a clean artist's canvas. Dynamic lighting creates soft shadows behind the floating paint strokes. Colorful, expressive, tactile texture, 4k detail.'
>>> image = pipe(prompt, negative_prompt="", num_inference_steps=50, guidance_scale=5.0).images[0]
>>> image.save("ovis_image.png")
```

#### encode_prompt[[diffusers.OvisImagePipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, max_sequence_length: int = 256, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ovis_image/pipeline_ovis_image.py#L269)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d'image. Utilisé uniquement lorsque `do_classifier_free_guidance` est `True`. S'il n'est pas défini, une chaîne vide est utilisée.

do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut également encoder le `negative_prompt` pour le guidage sans classifieur.

device : (`torch.device`) : appareil torch

num_images_per_prompt (`int`) : nombre d'images à générer par invite

max_sequence_length (`int`, *facultatif*, valeur par défaut 256) : Longueur maximale de la séquence à utiliser pour le `prompt`.

prompt_embeds (`torch.FloatTensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

negative_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Incrustations de texte négatif pré-générées. Si non fournies, elles sont générées à partir de `negative_prompt`.

## OvisImagePipelineOutput[[diffusers.pipelines.ovis_image.OvisImagePipelineOutput]]

#### diffusers.pipelines.ovis_image.OvisImagePipelineOutput[[diffusers.pipelines.ovis_image.OvisImagePipelineOutput]]

```python
diffusers.pipelines.ovis_image.OvisImagePipelineOutput(images: list[PIL.Image.Image, numpy.ndarray])
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/ovis_image/pipeline_output.py#L24)

**Paramètres :**

images (`list[PIL.Image.Image]` ou `np.ndarray`) : Liste d'images PIL débruitées de longueur `batch_size` ou tableau numpy de forme `(batch_size, height, width, num_channels)`. Les images PIL ou le tableau numpy présentent les images débruitées du pipeline de diffusion.

Classe de sortie pour les pipelines Ovis-Image.