# Ovis-Image

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

Ovis-Image es un modelo de texto a imagen de 7B optimizado específicamente para la renderización de texto de alta calidad, diseñado para operar de manera eficiente bajo restricciones computacionales estrictas.

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

El resumen del artículo es:

*Presentamos Ovis-Image, un modelo de texto a imagen de 7B optimizado específicamente para el renderizado de texto de alta calidad, diseñado para operar de manera eficiente bajo restricciones computacionales estrictas. Basado en nuestro marco de trabajo anterior Ovis-U1, Ovis-Image integra un decodificador visual basado en difusión con el backbone multimodal más potente Ovis 2.5, aprovechando un pipeline de entrenamiento centrado en el texto que combina el preentrenamiento a gran escala con refinamientos de posentrenamiento cuidadosamente diseñados. A pesar de su arquitectura compacta, Ovis-Image logra un rendimiento de renderizado de texto comparable al de modelos abiertos significativamente más grandes, como Qwen-Image, y se acerca a sistemas de código cerrado como Seedream y GPT4o. Crucialmente, el modelo sigue siendo desplegable en una sola GPU de gama alta con memoria moderada, reduciendo la brecha entre el renderizado de texto de nivel frontera y el despliegue práctico. Nuestros resultados indican que combinar un backbone multimodal potente con una receta de entrenamiento enfocada en el texto y cuidadosamente diseñada es suficiente para lograr un renderizado de texto bilingüe confiable sin recurrir a modelos de gran tamaño o propietarios.*

**Aspectos destacados**:

*   **Renderizado de texto potente a una escala compacta de 7B**: Ovis-Image es un modelo de texto a imagen de 7B que ofrece una calidad de renderizado de texto comparable a la de sistemas mucho más grandes de la clase de 20B, como Qwen-Image, y es competitivo con modelos de código cerrado líderes como GPT4o en escenarios centrados en texto, todo ello manteniéndose lo suficientemente pequeño para ejecutarse en hardware ampliamente accesible.
*   **Alta fidelidad en prompts con mucho texto y sensibles al diseño**: El modelo destaca en prompts que exigen una alineación precisa entre el contenido lingüístico y la tipografía renderizada (p. ej., carteles, banners, logotipos, maquetas de interfaz, infografías), generando texto legible, correctamente escrito y semánticamente coherente en una amplia variedad de fuentes, tamaños y relaciones de aspecto, sin comprometer la calidad visual general.
*   **Eficiencia y capacidad de despliegue**: Con su presupuesto de 7B parámetros y su arquitectura optimizada, Ovis-Image cabe en una sola GPU de gama alta con memoria moderada, soporta un uso interactivo de baja latencia y escala para el servicio de producción por lotes, llevando el renderizado de texto casi de frontera a aplicaciones donde los modelos con decenas de miles de millones de parámetros no son prácticos.

Este pipeline fue aportado por el equipo Ovis-Image. La base de código original se puede encontrar [aquí](https://github.com/AIDC-AI/Ovis-Image).

Modelos disponibles:

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

Consulte esta [colección](https://huggingface.co/collections/AIDC-AI/ovis-image) para obtener más información.

## OvisImagePipeline[[diffusers.OvisImagePipeline]]

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

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

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

**Parámetros:**

transformer ([OvisImageTransformer2DModel](/docs/diffusers/main/es/api/models/ovisimage_transformer2d#diffusers.OvisImageTransformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

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

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

El pipeline Ovis-Image para la generación de imágenes a partir de texto.

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

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` no es mayor que `1`).

guidance_scale (`float`, *opcional*, valor predeterminado 1.0) : La guía de clasificación libre (escala de guía) se habilita cuando `guidance_scale` > 1 y se proporciona `negative_prompt`.

height (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.

width (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.

num_inference_steps (`int`, *opcional*, valor predeterminado 50) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`.

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.FloatTensor`, *opcional*) : Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se usarán como entradas para la generación de imágenes. Se pueden utilizar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.flux.FluxPipelineOutput` en lugar de una tupla simple.

joint_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`List`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

max_sequence_length (`int` por defecto 512) : Longitud máxima de secuencia para usar con el `prompt`.

**Devuelve:** [OvisImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/ovis_image#diffusers.pipelines.ovis_image.OvisImagePipelineOutput) o `tuple`

[OvisImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/ovis_image#diffusers.pipelines.ovis_image.OvisImagePipelineOutput) si `return_dict` es True, de lo contrario una `tuple`. Al devolver una tupla, el primer elemento es una lista con las imágenes generadas.

Función invocada al llamar a la pipeline para la generación.

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

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen. Se utiliza solo cuando `do_classifier_free_guidance` es `True`. Si no se define, se utiliza una cadena vacía.

do_classifier_free_guidance (`bool`, *opcional*, valor predeterminado `True`) : Si se debe codificar también el `negative_prompt` para la guía libre de clasificador.

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

num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt

max_sequence_length (`int`, *opcional*, valor predeterminado 256) : Longitud máxima de la secuencia a utilizar para el `prompt`.

prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pregenerados. Si no se proporcionan, se generan 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])
```

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

**Parámetros:**

images (`list[PIL.Image.Image]` o `np.ndarray`) : Lista de imágenes PIL desruidas de longitud `batch_size` o matriz numpy de forma `(batch_size, height, width, num_channels)`. Las imágenes PIL o la matriz numpy presentan las imágenes desruidas del pipeline de difusión.

Clase de salida para las tuberías de Ovis-Image.