# Bria 3.2 Bria 3.2 es el modelo de texto a imagen de próxima generación, listo para uso comercial. Con solo 4 mil millones de parámetros, ofrece una estética y un renderizado de texto excepcionales, evaluado para proporcionar resultados equivalentes a los de los principales modelos de código abierto y superando a otros modelos con licencia. Además de estar construido íntegramente con datos con licencia, 3.2 ofrece varias ventajas para el uso empresarial y comercial: - Cómputo eficiente: el modelo es 3 veces más pequeño que los modelos equivalentes del mercado (4B de parámetros frente a los 12B de parámetros de otros modelos de código abierto) - Consistencia de la arquitectura: misma arquitectura que la 3.1, ideal para usuarios que buscan actualizar sin interrupciones. - Aceleración del ajuste fino: ajuste fino 2 veces más rápido en L40S y A100. Los puntos de control originales del modelo para Bria 3.2 se pueden encontrar [aquí](https://huggingface.co/briaai/BRIA-3.2). El repositorio de Github para Bria 3.2 se puede encontrar [aquí](https://github.com/Bria-AI/BRIA-3.2). Si desea obtener más información sobre la plataforma Bria y acceder a una prueba gratuita, visite [bria.ai](https://bria.ai). ## Uso _Como el modelo está restringido, antes de usarlo con diffusers primero debes ir a la [página de Bria 3.2 en Hugging Face](https://huggingface.co/briaai/BRIA-3.2), completar el formulario y aceptar la restricción. Una vez dentro, necesitas iniciar sesión para que tu sistema sepa que has aceptado la restricción._ Use el siguiente comando para iniciar sesión: ```bash hf auth login ``` ## BriaPipeline[[diffusers.BriaPipeline]] #### diffusers.BriaPipeline[[diffusers.BriaPipeline]] ```python diffusers.BriaPipeline(transformer: BriaTransformer2DModel, scheduler: diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler | diffusers.schedulers.scheduling_utils.KarrasDiffusionSchedulers, vae: AutoencoderKL, text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/bria/pipeline_bria.py#L89) **Parámetros:** transformer ([BriaTransformer2DModel](/docs/diffusers/main/es/api/models/bria_transformer#diffusers.BriaTransformer2DModel)) : 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 (`T5EncoderModel`) : Codificador de texto congelado. Bria utiliza [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), específicamente la variante [t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl). tokenizer (`T5TokenizerFast`) : Tokenizador de la clase [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer). Basado en FluxPipeline con varios cambios: - embeddings no agrupados - Usamos relleno con ceros para los prompts - No hay un *embedding* de guía ya que esta no es una versión destilada #### __call__[[diffusers.BriaPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 30, timesteps: list = None, guidance_scale: float = 5, negative_prompt: str | list[str] | 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, 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 = ['latents'], max_sequence_length: int = 128, clip_value: None | float = None, normalize: bool = False) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/bria/pipeline_bria.py#L448) **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. 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. timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente. guidance_scale (`float`, *opcional*, valor predeterminado 5.0) -- **Devuelve:** `~pipelines.bria.BriaPipelineOutput` o `tuple` `~pipelines.bria.BriaPipelineOutput` 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. <<<<<<< HEAD Escala de guía tal como se define en [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://arxiv.org/pdf/2205.11487.pdf). La escala de guía se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al texto de `prompt`, generalmente a costa de una menor calidad de imagen. negative_prompt (`str` o `list[str]`, *opcional*): ======= Escala de guía tal como se define en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al texto de `prompt`, generalmente a costa de una menor calidad de imagen. negative_prompt (`str` o `list[str]`, *opcional*): >>>>>>> main Los prompt o prompts que no deben guiar la generación de la imagen. Si no se definen, hay que pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). num_images_per_prompt (`int`, *opcional*, valor predeterminado 1): El número de imágenes a generar por prompt. 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, para usarse como entradas para la generación de imágenes. Se puede usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio proporcionado. prompt_embeds (`torch.FloatTensor`, *opcional*): Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *por ejemplo* el ponderado del prompt. Si no se proporcionan, los embeddings de texto se generarán desde el argumento de entrada `prompt`. negative_prompt_embeds (`torch.FloatTensor`, *opcional*): Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *por ejemplo* el ponderado del prompt. Si no se proporcionan, negative_prompt_embeds se generará desde el argumento de entrada `negative_prompt`. output_type (`str`, *opcional*, valor predeterminado `"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`): Si se devuelve un `~pipelines.bria.BriaPipelineOutput` en lugar de una tupla simple. attention_kwargs (`dict`, *opcional*): Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` definido 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 tensors 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 tensors especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables listadas en el atributo `._callback_tensor_inputs` de su clase de pipeline. max_sequence_length (`int` valor predeterminado 256): Longitud máxima de secuencia para usar con el `prompt`. clip_value (`float`, *opcional*): Si se establece, el ruido predicho se recorta al rango `[-clip_value, clip_value]` en cada paso de desruido. normalize (`bool`, *opcional*, valor predeterminado `False`): Si se normaliza el ruido predicho en cada paso de desruido. Ejemplos: ```py >>> import torch >>> from diffusers import BriaPipeline >>> pipe = BriaPipeline.from_pretrained("briaai/BRIA-3.2", torch_dtype=torch.bfloat16) >>> pipe.to("cuda") # BRIA's T5 text encoder is sensitive to precision. We need to cast it to bfloat16 and keep the final layer in float32. >>> pipe.text_encoder = pipe.text_encoder.to(dtype=torch.bfloat16) >>> for block in pipe.text_encoder.encoder.block: ... block.layer[-1].DenseReluDense.wo.to(dtype=torch.float32) # BRIA's VAE is not supported in mixed precision, so we use float32. >>> if pipe.vae.config.shift_factor == 0: ... pipe.vae.to(dtype=torch.float32) >>> prompt = "Photorealistic food photography of a stack of fluffy pancakes on a white plate, with maple syrup being poured over them. On top of the pancakes are the words 'BRIA 3.2' in bold, yellow, 3D letters. The background is dark and out of focus." >>> image = pipe(prompt).images[0] >>> image.save("bria.png") ``` #### encode_prompt[[diffusers.BriaPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 128, lora_scale: float | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/bria/pipeline_bria.py#L146) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar device : (`torch.device`): dispositivo de torch num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt do_classifier_free_guidance (`bool`) : si se debe usar o no la guía libre de clasificador 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` es menor que `1`). 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`.