# Ovis-Image

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

Ovis-Image é um modelo de texto para imagem de 7B otimizado especificamente para renderização de texto de alta qualidade, projetado para operar de forma eficiente sob restrições computacionais rigorosas.

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

O resumo do artigo é:

*Apresentamos o Ovis-Image, um modelo de texto para imagem de 7B otimizado especificamente para renderização de texto de alta qualidade, projetado para operar de forma eficiente sob restrições computacionais rigorosas. Construído sobre nosso framework anterior Ovis-U1, o Ovis-Image integra um decodificador visual baseado em difusão com o backbone multimodal mais robusto Ovis 2.5, aproveitando um pipeline de treinamento centrado em texto que combina pré-treinamento em larga escala com refinamentos de pós-treinamento cuidadosamente ajustados. Apesar de sua arquitetura compacta, o Ovis-Image atinge um desempenho de renderização de texto comparável ao de modelos abertos significativamente maiores, como o Qwen-Image, e se aproxima de sistemas proprietários como Seedream e GPT4o. Crucialmente, o modelo permanece implantável em uma única GPU de alto desempenho com memória moderada, reduzindo a lacuna entre a renderização de texto de nível de fronteira e a implantação prática. Nossos resultados indicam que combinar um backbone multimodal robusto com uma receita de treinamento focada em texto e cuidadosamente projetada é suficiente para alcançar uma renderização de texto bilíngue confiável sem recorrer a modelos excessivamente grandes ou proprietários.*

**Destaques**:

*   **Renderização de texto robusta em uma escala compacta de 7B**: Ovis-Image é um modelo de texto para imagem de 7B que oferece qualidade de renderização de texto comparável a sistemas muito maiores da classe de 20B, como Qwen-Image, e competitivo com modelos fechados de ponta, como GPT4o, em cenários centrados em texto, mantendo-se pequeno o suficiente para rodar em hardware amplamente acessível.
*   **Alta fidelidade em prompts com muito texto e sensíveis ao layout**: O modelo se destaca em prompts que exigem alinhamento preciso entre o conteúdo linguístico e a tipografia renderizada (por exemplo, pôsteres, banners, logotipos, mockups de interface, infográficos), produzindo texto legível, corretamente grafado e semanticamente consistente em diversas fontes, tamanhos e proporções de aspecto, sem comprometer a qualidade visual geral.
*   **Eficiência e capacidade de implantação**: Com seu orçamento de 7B parâmetros e arquitetura otimizada, o Ovis-Image cabe em uma única GPU de alto desempenho com memória moderada, suporta uso interativo de baixa latência e escala para produção em lote, trazendo renderização de texto próxima ao estado da arte para aplicações em que modelos com dezenas de bilhões de parâmetros são impraticáveis.

Este pipeline foi contribuído pela equipe Ovis-Image. A base de código original pode ser encontrada [aqui](https://github.com/AIDC-AI/Ovis-Image).

Modelos disponíveis:

| Model | dtype recomendado |
|:-----:|:-----------------:|
| [`AIDC-AI/Ovis-Image-7B`](https://huggingface.co/AIDC-AI/Ovis-Image-7B) | `torch.bfloat16` |

Consulte esta [coleção](https://huggingface.co/collections/AIDC-AI/ovis-image) para mais informações.

## OvisImagePipeline[[diffusers.OvisImagePipeline]]

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

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

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

**Parâmetros:**

transformer ([OvisImageTransformer2DModel](/docs/diffusers/v0.43.0/pt/api/models/ovisimage_transformer2d#diffusers.OvisImageTransformer2DModel)) : Arquitetura de Transformer condicional (MMDiT) para desruidar os latentes da imagem codificada.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.

text_encoder (`Qwen3Model`) : Codificador de texto da classe [Qwen3Model](https://huggingface.co/docs/transformers/en/model_doc/qwen3#transformers.Qwen3Model).

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

O pipeline Ovis-Image para geração de imagens a partir de texto.

Referência: https://github.com/AIDC-AI/Ovis-Image

#### __call__[[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)
```

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

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso.

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` no lugar. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` não for maior que `1`).

guidance_scale (`float`, *opcional*, padrão 1.0) : A orientação de classificação livre (escala de orientação) é ativada quando `guidance_scale` > 1 e `negative_prompt` é fornecido.

height (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A altura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados.

width (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A largura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados.

num_inference_steps (`int`, *opcional*, padrão 50) : O número de etapas de desruidamento. Mais etapas de desruidamento geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar no processo de desruidamento com agendadores que suportam um argumento `sigmas` em seu método `set_timesteps`. Se não definido, o comportamento padrão quando `num_inference_steps` é passado será usado.

num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.

generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um ou uma lista de [geradores do torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística.

latents (`torch.FloatTensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes será gerado por amostragem usando o `generator` aleatório fornecido.

prompt_embeds (`torch.FloatTensor`, *opcional*) : Emojis de texto pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não for fornecido, os emojis de texto serão gerados a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.

output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` ou `np.array`.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `~pipelines.flux.FluxPipelineOutput` em vez de uma tupla simples.

joint_attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, *opcional*) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência. A função é chamada com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`List`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

max_sequence_length (`int` padrão é 512) : Comprimento máximo da sequência a ser usado com o `prompt`.

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

[OvisImagePipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/ovis_image#diffusers.pipelines.ovis_image.OvisImagePipelineOutput) se `return_dict` for True, caso contrário, uma `tuple`. Ao retornar uma tupla, o primeiro elemento é uma lista com as imagens geradas.

Função invocada ao chamar o pipeline para geração.

Exemplos:
```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)
```

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

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Usado apenas quando `do_classifier_free_guidance` é `True`. Se não definido, uma string vazia é usada.

do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se também deve codificar o `negative_prompt` para o classifier-free guidance.

device : (`torch.device`): dispositivo torch

num_images_per_prompt (`int`) : número de imagens que devem ser geradas por prompt

max_sequence_length (`int`, *opcional*, padrão 256) : Comprimento máximo da sequência a ser usado para o `prompt`.

prompt_embeds (`torch.FloatTensor`, *opcional*) : Emojis de texto pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não for fornecido, os emojis de texto serão gerados a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embebimentos de texto negativos pré-gerados. Se não fornecidos, são gerados a 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])
```

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

**Parâmetros:**

images (`list[PIL.Image.Image]` ou `np.ndarray`) : Lista de imagens PIL desruidas de comprimento `batch_size` ou array numpy de forma `(batch_size, height, width, num_channels)`. As imagens PIL ou o array numpy apresentam as imagens desruidas do pipeline de difusão.

Classe de saída para os pipelines do Ovis-Image.