# Integrações do PEFT

Os benefícios práticos do PEFT se estendem a outras bibliotecas do Hugging Face, como [Diffusers](https://hf.co/docs/diffusers) e [Transformers](https://hf.co/docs/transformers). Um dos principais benefícios do PEFT é que um arquivo de adaptador gerado por um método PEFT é muito menor que o modelo original, o que torna extremamente fácil gerenciar e usar múltiplos adaptadores. Você pode usar um único modelo base pré-treinado para várias tarefas simplesmente carregando um novo adaptador ajustado para a tarefa que está resolvendo. Ou você pode combinar múltiplos adaptadores com um modelo de difusão de texto para imagem para criar novos efeitos.

Este tutorial mostrará como o PEFT pode ajudar você a gerenciar adaptadores em Diffusers e Transformers.

## Diffusers

Diffusers é uma biblioteca de IA generativa para criar imagens e vídeos a partir de texto ou imagens com modelos de difusão. LoRA é um método de treinamento especialmente popular para modelos de difusão, pois permite treinar e compartilhar modelos de difusão rapidamente para gerar imagens em novos estilos. Para facilitar o uso e a experimentação de múltiplos modelos LoRA, o Diffusers utiliza a biblioteca PEFT para ajudar a gerenciar diferentes adaptadores para inferência.

Por exemplo, carregue um modelo base e, em seguida, carregue o adaptador [artificialguybr/3DRedmond-V1](https://huggingface.co/artificialguybr/3DRedmond-V1) para inferência com o método [`load_lora_weights`](https://huggingface.co/docs/diffusers/v0.24.0/en/api/loaders/lora#diffusers.loaders.LoraLoaderMixin.load_lora_weights). O argumento `adapter_name` no método de carregamento é habilitado pelo PEFT e permite definir um nome para o adaptador, facilitando sua referência.

```py
import torch
from diffusers import DiffusionPipeline

device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"

pipeline = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to(device)
pipeline.load_lora_weights(
    "peft-internal-testing/artificialguybr__3DRedmond-V1", 
    weight_name="3DRedmond-3DRenderStyle-3DRenderAF.safetensors", 
    adapter_name="3d"
)
image = pipeline("sushi rolls shaped like kawaii cat faces").images[0]
image
```

    

Agora vamos tentar outro modelo LoRA interessante, [ostris/super-cereal-sdxl-lora](https://huggingface.co/ostris/super-cereal-sdxl-lora). Tudo o que você precisa fazer é carregar e nomear este novo adaptador com `adapter_name` e usar o método [`set_adapters`](https://huggingface.co/docs/diffusers/api/loaders/unet#diffusers.loaders.UNet2DConditionLoadersMixin.set_adapters) para defini-lo como o adaptador ativo no momento.

```py
pipeline.load_lora_weights(
    "ostris/super-cereal-sdxl-lora", 
    weight_name="cereal_box_sdxl_v1.safetensors", 
    adapter_name="cereal"
)
pipeline.set_adapters("cereal")
image = pipeline("sushi rolls shaped like kawaii cat faces").images[0]
image
```

    

Por fim, você pode chamar o método [`disable_lora`](https://huggingface.co/docs/diffusers/api/loaders/unet#diffusers.loaders.UNet2DConditionLoadersMixin.disable_lora) para restaurar o modelo base.

```py
pipeline.disable_lora()
```

Saiba mais sobre como o PEFT suporta o Diffusers no tutorial [Inferência com PEFT](https://huggingface.co/docs/diffusers/tutorials/using_peft_for_inference).

## Transformers

🤗 [Transformers](https://hf.co/docs/transformers) é uma coleção de modelos pré-treinados para todos os tipos de tarefas em todas as modalidades. Você pode carregar esses modelos para treinamento ou inferência. Muitos dos modelos são grandes modelos de linguagem (LLMs), então faz sentido integrar o PEFT com o Transformers para gerenciar e treinar adaptadores.

Carregue um modelo pré-treinado base para treinar.

```py
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
```

Em seguida, adicione uma configuração de adaptador para especificar como adaptar os parâmetros do modelo. Chame o método [add_adapter()](/docs/peft/v0.22.0/pt/package_reference/peft_model#peft.PeftModel.add_adapter) para adicionar a configuração ao modelo base.

```py
from peft import LoraConfig

peft_config = LoraConfig(
    lora_alpha=16,
    lora_dropout=0.1,
    r=64,
    bias="none",
    task_type="CAUSAL_LM"
)
model.add_adapter(peft_config)
```

Agora você pode treinar o modelo com a classe [Trainer](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer) do Transformers ou com qualquer outro framework de treinamento que preferir.

Para usar o modelo recém-treinado para inferência, a classe [AutoModel](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModel) usa o PEFT no backend para carregar os pesos do adaptador e o arquivo de configuração em um modelo pré-treinado base.

```py
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-350m-lora")
```

Alternativamente, você pode usar os [Pipelines](https://huggingface.co/docs/transformers/en/main_classes/pipelines) do transformers para carregar o modelo e executar inferências de forma conveniente:

```py
from transformers import pipeline

model = pipeline("text-generation", "peft-internal-testing/opt-350m-lora")
print(model("Hello World"))
```

Se você estiver interessado em comparar ou usar mais de um adaptador, pode chamar o método [add_adapter()](/docs/peft/v0.22.0/pt/package_reference/peft_model#peft.PeftModel.add_adapter) para adicionar a configuração do adaptador ao modelo base. O único requisito é que o tipo de adaptador seja o mesmo (não é possível misturar um adaptador LoRA e um adaptador LoHa).

```py
from transformers import AutoModelForCausalLM
from peft import LoraConfig

model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
model.add_adapter(lora_config_1, adapter_name="adapter_1")
```

Chame [add_adapter()](/docs/peft/v0.22.0/pt/package_reference/peft_model#peft.PeftModel.add_adapter) novamente para anexar um novo adaptador ao modelo base.

```py
model.add_adapter(lora_config_2, adapter_name="adapter_2")
```

Em seguida, você pode usar [set_adapter()](/docs/peft/v0.22.0/pt/package_reference/peft_model#peft.PeftModel.set_adapter) para definir o adaptador ativo atual.

```py
model.set_adapter("adapter_1")
output = model.generate(**inputs)
print(tokenizer.decode(output_disabled[0], skip_special_tokens=True))
```

Para desativar o adaptador, chame o método [disable_adapters](https://github.com/huggingface/transformers/blob/4e3490f79b40248c53ee54365a9662611e880892/src/transformers/integrations/peft.py#L313).

```py
model.disable_adapters()
```

O [enable_adapters](https://github.com/huggingface/transformers/blob/4e3490f79b40248c53ee54365a9662611e880892/src/transformers/integrations/peft.py#L336) pode ser usado para reativar os adaptadores.

Se você tiver curiosidade, confira o tutorial [Carregar e treinar adaptadores com PEFT](https://huggingface.co/docs/transformers/main/peft) para saber mais.

