# Bria Fibo Edit

Fibo Edit é um modelo de imagem-para-imagem com 8B parâmetros que introduz um novo paradigma de controle estruturado, operando com entradas JSON pareadas com imagens de origem para habilitar fluxos de trabalho de edição determinísticos e repetíveis. Com mascaramento nativo para precisão granular, ele vai além da difusão baseada apenas em prompts para oferecer controle explícito e interpretável, otimizado para ambientes de produção. Sua arquitetura leve é projetada para customização profunda, capacitando pesquisadores a construir modelos especializados de "Edit" para tarefas específicas de domínio, ao mesmo tempo em que entrega qualidade estética de alto nível

Consulte a [página](https://huggingface.co/briaai/Fibo-Edit-1.5-base) do Bria Fibo Edit no Hugging Face para saber mais. Um checkpoint destilado está disponível em [Fibo-Edit-1.5-turbo](https://huggingface.co/briaai/Fibo-Edit-1.5-turbo).

## Uso

_Como o modelo é restrito, antes de usá-lo com diffusers, você precisa primeiro acessar a [página do Bria Fibo Edit no Hugging Face](https://huggingface.co/briaai/Fibo-Edit-1.5-base), preencher o formulário e aceitar a restrição. Depois de ter acesso, é necessário fazer login para que o seu sistema saiba que você aceitou a restrição._

Use o comando abaixo para fazer login:

```bash
hf auth login
```

## BriaFiboEditPipeline[[diffusers.BriaFiboEditPipeline]]

#### diffusers.BriaFiboEditPipeline[[diffusers.BriaFiboEditPipeline]]

```python
diffusers.BriaFiboEditPipeline(transformer: BriaFiboTransformer2DModel, scheduler: typing.Union[diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler, diffusers.schedulers.scheduling_utils.KarrasDiffusionSchedulers], vae: AutoencoderKLWan, text_encoder: SmolLM3ForCausalLM, tokenizer: AutoTokenizer)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/bria_fibo/pipeline_bria_fibo_edit.py#L240)

**Parâmetros:**

transformer (`BriaFiboTransformer2DModel`) : O modelo de transformer para modelagem de difusão 2D.

scheduler (`FlowMatchEulerDiscreteScheduler` ou `KarrasDiffusionSchedulers`) : Agendador a ser usado com `transformer` para desruidar os latentes codificados.

vae (`AutoencoderKLWan`) : Autoencoder Variacional para codificar e decodificar imagens para e a partir de representações latentes.

text_encoder (`SmolLM3ForCausalLM`) : Codificador de texto para processar prompts de entrada.

tokenizer (`AutoTokenizer`) : Tokenizer usado para processar os prompts de texto de entrada para o text_encoder.

#### __call__[[diffusers.BriaFiboEditPipeline.__call__]]

```python
__call__(prompt: typing.Union[str, typing.List[str]] = None, image: typing.Union[PIL.Image.Image, typing.List[PIL.Image.Image], NoneType] = None, mask: typing.Union[torch.FloatTensor, PIL.Image.Image, typing.List[PIL.Image.Image], typing.List[torch.FloatTensor], numpy.ndarray, typing.List[numpy.ndarray], NoneType] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 30, timesteps: typing.List[int] = None, seed: int | None = None, guidance_scale: float = 5, negative_prompt: typing.Union[str, typing.List[str], NoneType] = None, num_images_per_prompt: typing.Optional[int] = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, output_type: str = 'pil', return_dict: bool = True, joint_attention_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int, typing.Dict], NoneType]] = None, callback_on_step_end_tensor_inputs: typing.List[str] = ['latents'], max_sequence_length: int = 3000, do_patching = False, _auto_resize: bool = True)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/bria_fibo/pipeline_bria_fibo_edit.py#L599)

**Parâmetros:**

prompt (`str` ou `List[str]`) : O prompt ou os prompts para orientar a geração da imagem.

image (`PIL.Image.Image` ou `List[PIL.Image.Image]`, *opcional*) : Uma ou mais imagens de referência para orientar a geração da imagem. Uma lista é interpretada como múltiplas referências (não um lote): cada referência é codificada pelo VAE em sua própria proporção de aspecto e posicionada em seu próprio plano de tempo RoPE 1, 2, ... . Se não for definida, o pipeline gera uma imagem do zero.

mask (`PipelineMaskInput`, *opcional*) : Máscara opcional que define a região de `image` a ser editada. Os pixels cobertos pela máscara são regenerados, enquanto o restante da imagem é preservado.

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 30) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

seed (`int`, *opcional*) : Uma semente usada para tornar a geração determinística.

timesteps (`List[int]`, *opcional*) : Passos de tempo personalizados para usar no processo de remoção de ruído com agendadores que suportam um argumento `timesteps` em seu método `set_timesteps`. Se não definido, o comportamento padrão quando `num_inference_steps` é passado será usado. Deve estar em ordem decrescente.

guidance_scale (`float`, *opcional*, padrão 5.0) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem.

negative_prompt (`str` ou `List[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).

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.

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.stable_diffusion_xl.StableDiffusionXLPipelineOutput` 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 é 3000) : Comprimento máximo da sequência a ser usado com o `prompt`.

do_patching (`bool`, *opcional*, padrão `False`) : Se deve usar patching.

_auto_resize (`bool`, *opcional*, padrão `True`) : Se deve ajustar a resolução de saída padrão (obtida da primeira imagem de referência) às resoluções preferidas.

**Retorna:** `~pipelines.flux.BriaFiboPipelineOutput` ou `tuple`

`~pipelines.flux.BriaFiboPipelineOutput` 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.

Exemplo:
```python
import torch
from PIL import Image

from diffusers import BriaFiboEditPipeline
from diffusers.modular_pipelines import ModularPipelineBlocks

# This prompt-to-JSON block calls Gemini and needs GEMINI_API_KEY in the environment.
vlm_pipe = ModularPipelineBlocks.from_pretrained("briaai/FIBO-edit-gemini-prompt-to-JSON", trust_remote_code=True)
vlm_pipe = vlm_pipe.init_pipeline()

pipe = BriaFiboEditPipeline.from_pretrained(
    "briaai/Fibo-Edit-1.5-base",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")

image = Image.open("owl.png")
json_prompt = vlm_pipe(image=image, prompt="Make the owl into a cat").values["json_prompt"]

result = pipe(prompt=json_prompt, image=image, num_inference_steps=30, guidance_scale=5)

# Multiple reference images: pass a list. Each reference conditions the edit at its
# own aspect ratio; the output resolution follows the first reference.
owl, forest = Image.open("owl.png"), Image.open("forest.png")
json_prompt = vlm_pipe(
    image=[owl, forest], prompt="Place the owl from the first image in the forest from the second image"
).values["json_prompt"]
result = pipe(
    prompt=json_prompt,
    image=[owl, forest],
    num_inference_steps=30,
    guidance_scale=5,
)

# The distilled Turbo checkpoint edits in 4 steps without classifier-free guidance.
pipe = BriaFiboEditPipeline.from_pretrained("briaai/Fibo-Edit-1.5-turbo", torch_dtype=torch.bfloat16)
pipe.to("cuda")
result = pipe(prompt=json_prompt, image=[owl, forest], num_inference_steps=4, guidance_scale=1)
```

#### encode_prompt[[diffusers.BriaFiboEditPipeline.encode_prompt]]

```python
encode_prompt(prompt: typing.Union[str, typing.List[str]], device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, guidance_scale: float = 5, negative_prompt: typing.Union[str, typing.List[str], NoneType] = None, max_sequence_length: int = 3000, lora_scale: bool | None = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/bria_fibo/pipeline_bria_fibo_edit.py#L365)

**Parâmetros:**

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

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

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

guidance_scale (`float`) : Escala de orientação para orientação livre de classificador.

negative_prompt (`str` ou `List[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).

#### prepare_reference_latents[[diffusers.BriaFiboEditPipeline.prepare_reference_latents]]

```python
prepare_reference_latents(image: Image, num_channels_latents: int, dtype: dtype, device: device, do_patching: bool = False, reference_index: int = 1)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/bria_fibo/pipeline_bria_fibo_edit.py#L992)

Codifique uma referência PIL única em seu próprio tamanho usando VAE e empacote-a como um fluxo de tokens de contexto de edição.