# C3A: Ajuste fino eficiente en parámetros mediante convolución circular

[C3A](https://huggingface.co/papers/2407.19342) es una técnica de ajuste fino eficiente en parámetros que aprovecha la Convolución Circular para lograr una adaptación de alto rango dentro de límites de recursos razonables.

Tenga en cuenta que debe usar una tasa de aprendizaje (LR) mucho mayor para C3A que para otros métodos. Por ejemplo, una LR de 1e-1 para C3A es un buen punto de partida. Además, se debe usar un decaimiento de peso mucho menor. Puede consultar la carpeta `method_comparison` para más detalles.

En cuanto a `block_size`, afecta a los parámetros ajustables y al rendimiento. Para empezar, puedes elegir un $\mathrm{gcd}(d_1,d_2)$ cercano a $\frac{\sqrt{d_1 \times d_2}}{r}$, donde $r$ es el rango de LoRA que usarías para esta tarea.

C3A tiene actualmente las siguientes restricciones:

- Solo se admiten capas `nn.Linear`.
- No se admiten capas cuantizadas.
- El tamaño de bloque debe ser un divisor común de los tamaños de entrada y salida de las capas objetivo.

Si estas restricciones no se ajustan a su caso de uso, considere otros métodos.

El resumen del artículo es:

> La Adaptación de Bajo Rango (LoRA) ha ganado popularidad para el ajuste fino de grandes modelos de base, aprovechando matrices de bajo rango $\mathbf{A}$ y $\mathbf{B}$ para representar los cambios de pesos (es decir, $\Delta \mathbf{W} = \mathbf{B} \mathbf{A}$). Este método reduce los parámetros entrenables y mitiga el alto consumo de memoria asociado con las matrices delta completas al multiplicar secuencialmente $\mathbf{A}$ y $\mathbf{B}$ con la activación. A pesar de su éxito, la característica intrínseca de bajo rango puede limitar su rendimiento. Aunque se han propuesto varias variantes para abordar este problema, a menudo pasan por alto la crucial eficiencia computacional y de memoria que aporta LoRA. En este artículo, proponemos la Adaptación de Convolución Circular (C3A), que no solo logra una adaptación de alto rango con un rendimiento mejorado, sino que también destaca tanto en potencia computacional como en utilización de memoria. Experimentos extensos demuestran que C3A supera consistentemente a LoRA y sus variantes en diversas tareas de ajuste fino.

## Resumen de las pruebas de rendimiento

<iframe src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=C3A" frameborder="0" width="850" height="1000"
>

# API

## C3AConfig[[peft.C3AConfig]]

#### peft.C3AConfig[[peft.C3AConfig]]

```python
peft.C3AConfig(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, block_size: int = 256, target_modules: Optional[Union[list[str], str]] = None, bias: str = 'none', modules_to_save: Optional[list[str]] = None, layers_to_transform: Optional[Union[list[int], int]] = None, layers_pattern: Optional[Union[list[str], str]] = None, block_size_pattern: Optional[dict] = <factory>, init_weights: Optional[Union[bool, Literal['gaussian', 'kaiming_uniform', 'xavier_uniform']]] = 'xavier_uniform')
```

[Fuente](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/c3a/config.py#L25)

**Parámetros:**

block_size (`int`) : block size for C3A, must be divisible by both the input size and the output size of the target layer. If you have no idea what block_size you should use, set it to the greatest common divisor of all input & output sizes of your target layers. Increasing this would result in less parameters.

target_modules (`Union[list[str],str]`) : Los nombres de los módulos a los que se aplicará C3A.

bias (`str`) : Tipo de sesgo para C3A. Puede ser 'none', 'all' o 'c3a_only'. Si es 'all' o 'c3a_only', los sesgos correspondientes se actualizarán durante el entrenamiento. Tenga en cuenta que esto significa que, incluso al deshabilitar los adaptadores, el modelo no producirá la misma salida que habría producido el modelo base sin adaptación.

modules_to_save (`list[str]`) --lista de módulos, aparte de las capas C3A, que se configurarán como entrenables y se guardarán en el punto de control final.

layers_to_transform (`Union[list[int],int]`) : Los índices de las capas a transformar. Si se especifica este argumento, se aplicará C3A a los índices de capa indicados en esta lista. Si se pasa un solo entero, se aplicará C3A a la capa en ese índice.

layers_pattern (`str`) : El nombre del patrón de capa, utilizado solo si `layers_to_transform` es diferente de `None` y si el patrón de capa no está en el patrón de capas común.

block_size_pattern (`dict`) : El mapeo de nombres de capas o expresiones regulares a block_size que son diferentes de la especificada por defecto. Por ejemplo, `{"model.decoder.layers.0.encoder_attn.k_proj": 1280`}

init_weights (`Union[bool, Literal["gaussian", "kaiming_uniform", "xavier_uniform"]]`) : Por defecto, 'xavier_uniform'. Si se establece en `False`, también se utiliza 'xavier_uniform'. Para establecer los pesos en cero (haciendo que C3A sea una operación sin efecto), establezca el valor en `True`.

Esta es la clase de configuración para almacenar la configuración de un [C3AModel](/docs/peft/v0.22.0/es/package_reference/c3a#peft.C3AModel).

## C3AModel[[peft.C3AModel]]

#### peft.C3AModel[[peft.C3AModel]]

```python
peft.C3AModel(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)
```

[Fuente](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/c3a/model.py#L29)

**Parámetros:**

model (`torch.nn.Module`) : El modelo que se va a adaptar.

config ([C3AConfig](/docs/peft/v0.22.0/es/package_reference/c3a#peft.C3AConfig)) : La configuración del modelo C3A.

adapter_name (`str`) : El nombre del adaptador, por defecto es `"default"`.

**Devuelve:** `torch.nn.Module`

El modelo C3A.

Crea un modelo C3A a partir de un modelo de transformers preentrenado.

El método se describe en detalle en https://huggingface.co/papers/2407.19342.

**Atributos**:
- **model** ([PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel)) -- El modelo que se va a adaptar.
- **peft_config** ([C3AConfig](/docs/peft/v0.22.0/es/package_reference/c3a#peft.C3AConfig)): La configuración del modelo C3A.

