# FRoD: Ajuste fino eficiente de posto completo com graus rotacionais

FRoD é um método de ajuste fino eficiente em parâmetros que combina uma base de posto completo compartilhada com graus de rotação aprendíveis esparsos. A atualização do adaptador é expressa por meio de tensores de projeção fixos e coeficientes treináveis, o que permite que o FRoD aplique atualizações de posto completo mantendo o número de parâmetros treinados pequeno.

Artigo: [Full-Rank Efficient Fine-Tuning with Rotational Degrees](https://doi.org/10.1609/aaai.v40i31.39813).

Ao salvar os parâmetros do adaptador, é possível evitar o armazenamento dos tensores de projeção definindo `save_projection=False` no `FrodConfig`. Nesse caso, as projeções são restauradas a partir dos pesos do modelo base e da semente aleatória fixa de `projection_prng_key`. Isso reduz o tamanho do checkpoint, mas o padrão é `save_projection=True` para tornar o carregamento do checkpoint independente dos detalhes de regeneração.

Em comparação com o LoRA, o FRoD pode expressar uma atualização de posto completo em cada camada linear adaptada, treinando apenas os coeficientes diagonais e um conjunto esparsos de coeficientes de rotação fora da diagonal. Isso pode ser útil quando uma atualização de posto baixo é muito restritiva. A compensação é que o FRoD calcula tensores de projeção fixos a partir dos pesos base durante a injeção do adaptador, o que torna a configuração mais cara e a implementação menos amplamente suportada do que a do LoRA.

A inicialização da projeção pode ser lenta em modelos grandes, pois o FRoD executa decomposições de matrizes sobre as categorias de módulos de destino antes de injetar os adaptadores. Uma barra de progresso é exibida por padrão e pode ser desativada com `FrodConfig(progressbar=False)`.

Para treinamento com restrições de memória, `runtime_offload_base_weight=True` mantém os pesos base do alvo na CPU quando o caminho ativo do FRoD não os precisa. Essa é uma opção de opt-in, pois os métodos PEFT geralmente mantêm todos os parâmetros base no acelerador após mover o modelo e após as passadas de forward.

O FRoD possui atualmente a seguinte restrição:

- Somente as camadas `nn.Linear` e `transformers.pytorch_utils.Conv1D` são suportadas.

## Início rápido

```python
from transformers import AutoModelForSequenceClassification

from peft import FrodConfig, TaskType, get_peft_model

model = AutoModelForSequenceClassification.from_pretrained("google-bert/bert-base-uncased", num_labels=2)

peft_config = FrodConfig(
    task_type=TaskType.SEQ_CLS,
    target_modules=["query", "value"],
    modules_to_save=["classifier"],
    sparse_rate=0.02,
    frod_dropout=0.0,
    runtime_offload_base_weight=True,
)

model = get_peft_model(model, peft_config)
model.print_healthcheck()
```

## FrodConfig[[peft.FrodConfig]]

#### peft.FrodConfig[[peft.FrodConfig]]

```python
peft.FrodConfig(task_type: Optional[Union[str, TaskType]] = None, peft_type: Optional[Union[str, PeftType]] = None, auto_mapping: Optional[dict] = None, peft_version: Optional[str] = None, base_model_name_or_path: Optional[str] = None, revision: Optional[str] = None, inference_mode: bool = False, target_modules: Optional[Union[list[str], str]] = None, projection_prng_key: int = 0, save_projection: bool = True, frod_dropout: float = 0.0, fan_in_fan_out: bool = False, bias: str = 'none', modules_to_save: Optional[list[str]] = None, init_weights: bool = True, layers_to_transform: Optional[Union[list[int], int]] = None, layers_pattern: Optional[Union[list[str], str]] = None, sparse_rate: float = 0.01, regularization_alpha: float = 0.001, progressbar: bool = True, runtime_offload_base_weight: bool = False)
```

[Fonte](https://github.com/huggingface/peft/blob/main/src/peft/tuners/frod/config.py#L24)

**Parâmetros:**

target_modules (`Union[List[str], str]`) : Os nomes dos módulos aos quais aplicar o FRoD. Somente camadas lineares são suportadas.

projection_prng_key (`int`) : Semente aleatória usada ao inicializar o padrão COO esparsa do FRoD.

save_projection (`bool`) : Se os tensores de projeção FRoD devem ser salvos no state dict. Isso aumenta o tamanho do checkpoint, mas torna o recarregamento do adaptador independente da regeneração do cache local. O valor padrão é `True`.

frod_dropout (`float`) : A probabilidade de dropout para as camadas FRoD.

fan_in_fan_out (`bool`) : Defina como True se a camada a ser substituída armazena pesos como (fan_in, fan_out). Por exemplo, o gpt-2 usa `Conv1D`, que armazena pesos como (fan_in, fan_out), e portanto isso deve ser definido como `True`.

bias (`str`) : Tipo de viés para FRoD. Pode ser 'none', 'all' ou 'frod_only'. Se for 'all' ou 'frod_only', os vieses correspondentes serão atualizados durante o treinamento. Tenha em mente que isso significa que, mesmo ao desativar os adaptadores, o modelo não produzirá a mesma saída que o modelo base teria sem adaptação.

modules_to_save (`List[str]`) : Lista de módulos, exceto as camadas FRoD, que devem ser configurados como treináveis e salvos no checkpoint final.

init_weights (`bool`) : Se as camadas FRoD devem ter seus pesos inicializados com a inicialização padrão. Não altere esta configuração, exceto se você souber exatamente o que está fazendo.

layers_to_transform (`Union[List[int],int]`) : Os índices das camadas a serem transformados. Se esse argumento for especificado, as transformações FRoD serão aplicadas aos índices das camadas especificados nesta lista. Se um único inteiro for passado, as transformações FRoD serão aplicadas à camada neste índice.

layers_pattern (`Optional[Union[List[str], str]]`) : O nome do padrão da camada, usado apenas se `layers_to_transform` for diferente de `None`. Isso deve apontar para o `nn.ModuleList` do modelo, que frequentemente é chamado de `'layers'` ou `'h'`.

sparse_rate (`float`) : Fração das entradas fora da diagonal na matriz de rotação treinável esparsa. Valores maiores aumentam a capacidade e os parâmetros treináveis; valores menores são mais baratos. O padrão é `0.01`.

regularization_alpha (`float`) : Pequeno valor positivo usado durante a construção da base compartilhada a partir dos pesos base. Ele estabiliza o inverso da matriz quando as camadas na mesma categoria possuem pesos correlacionados. O valor padrão é `1e-3`.

progressbar (`bool`) : Se deve exibir uma barra de progresso durante a construção das projeções FRoD. A inicialização das projeções pode ser lenta em modelos grandes, pois executa decomposições de matrizes sobre as categorias dos módulos de destino. O valor padrão é `True`.

runtime_offload_base_weight (`bool`) : Se as pesos base do alvo devem ser mantidos na CPU quando o caminho ativo do FRoD não os precisa. Isso pode reduzir a memória de GPU, pois o FRoD reconstrói o peso adaptado diretamente, mas altera a convenção usual do PEFT de que todos os parâmetros base permanecem no acelerador após mover o modelo ou executar o forward. O padrão é `False`.

Esta é a classe de configuração para armazenar a configuração de um [FrodModel](/docs/peft/main/pt/package_reference/frod#peft.FrodModel).

Artigo: https://doi.org/10.1609/aaai.v40i31.39813.

## FrodModel[[peft.FrodModel]]

#### peft.FrodModel[[peft.FrodModel]]

```python
peft.FrodModel(model, peft_config: Union[PeftConfig, dict[str, PeftConfig]], adapter_name: str, low_cpu_mem_usage: bool = False, state_dict: Optional[dict[str, torch.Tensor]] = None)
```

[Fonte](https://github.com/huggingface/peft/blob/main/src/peft/tuners/frod/model.py#L101)