# GLoRA

La Adaptación de Bajo Rango Generalizada ([GLoRA](https://huggingface.co/papers/2306.07967)) es un método PEFT que generaliza LoRA y enfoques relacionados. GLoRA descompone las actualizaciones en rutas configurables (A, B, C, D, E), donde cada ruta puede utilizar una parametrización de bajo rango, vectorial, constante o deshabilitada, según la ruta.

Cada ruta admite uno de los cuatro modos de parametrización. Estos equilibran el **número de parámetros** frente a la **expresividad** (qué tan rica puede ser la actualización):

- `"lora"`: Descomposición de bajo rango (como LoRA estándar). Utiliza `r * (out + in)` parámetros y puede expresar correcciones de rango `r`. Es la más expresiva y la que más parámetros utiliza.
- `"vector"`: Un vector único (p. ej., forma `(out, 1)`), transmitido a lo largo de la matriz. Utiliza `O(out)` parámetros; solo escalado o desplazamiento por canal.
- `"constant"`: Un único escalar compartido entre todos los elementos. Utiliza 1 parámetro; es la opción menos expresiva entre las opciones entrenables.
- `"none"`: Ceros sin parámetros entrenables; deshabilita esa ruta por completo.

No todos los caminos aceptan todos los modos (por ejemplo, `config_D_E` no admite `"lora"`). Elegir `"lora"` en más caminos aumenta la capacidad y los parámetros entrenables; `"vector"`, `"constant"` o `"none"` reducen ambos.

GLoRA es especialmente útil para investigación y aplicaciones avanzadas en las que se desea experimentar con patrones de actualización estructurados y combinar múltiples mecanismos de adaptación en una sola capa.

A alto nivel, GLoRA modifica una capa lineal congelada con:

$$ W_{\mathrm{eff}} = W_0 + W_0 \odot A + B $$

$$ b_{\mathrm{eff}} = b_0 + b_0 \odot D + E + W_0 C $$

donde cada ruta se parametriza de forma independiente.

## GloraConfig[[peft.GloraConfig]]

#### peft.GloraConfig[[peft.GloraConfig]]

```python
peft.GloraConfig(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, r: int = 8, target_modules: list[str] | str | None = None, bias: str = 'none', modules_to_save: list[str] | None = None, config_A_B: typing.Literal['lora', 'vector', 'constant', 'none'] = 'lora', config_C: typing.Literal['lora', 'vector', 'none'] = 'lora', config_D_E: typing.Literal['vector', 'constant', 'none'] = 'constant', init_weights: bool = True)
```

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

**Parámetros:**

r (`int`) : Rango de la descomposición de bajo rango utilizada cuando una configuración se establece en `lora`.

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

config_A_B (`str`) : Parametrización para las matrices A y B (correcciones multiplicativas y aditivas de peso). Valores válidos: `lora`, `vector`, `constant`, `none`.

config_C (`str`) : Parametrización para la matriz C (acoplamiento de peso a sesgo: b += W0 @ C). Valores válidos: `lora`, `vector`, `none`.

config_D_E (`str`) : Parametrización para los escalares D y E (correcciones multiplicativas y aditivas de sesgo). No admite `lora` ya que D y E son vectores del tamaño del sesgo, no matrices. Valores válidos: `vector`, `constant`, `none`.

init_weights (`bool`) : Si es True (valor predeterminado), inicializa GLoRA como una operación nula (ceros). Si es False, utiliza la inicialización de kaiming para que el adaptador no sea una operación nula.

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

Glora modifica una capa lineal congelada W0 de la siguiente manera: `W_eff = W0 + W0 * A + B` y `b_eff = b0 + b0 * D + E + W0 @ C`.

Cada matriz (A, B, C, D, E) puede parametrizarse de forma independiente. Los valores de la configuración controlan cuántos parámetros se utilizan y qué formas pueden expresar:

- `lora`: Descomposición de bajo rango `Xd @ Xu` con formas `(out, r)` y `(r, in)`. Utiliza `r * (out + in)` parámetros y puede expresar cualquier corrección de rango r. Igual que el LoRA estándar.
- `vector`: un vector de columna de forma `(out, 1)`, que se difunde en toda la matriz. Utiliza `out` parámetros; solo permite escalado o desplazamiento por canal de salida.
- `constant`: Un único escalar compartido entre todos los elementos. Utiliza 1 parámetro; es el más restrictivo.
- `none`: Ceros, sin parámetros entrenables. Desactiva efectivamente esta ruta.

### Opciones de configuración clave
- `r`: Rango utilizado cuando una ruta se configura como `"lora"` (predeterminado: `8`).
- `target_modules`: Lista o expresión regular de nombres de módulos para adaptar (p. ej., `["q_proj", "v_proj"]`).
- `config_A_B`: Tipo de ruta para A y B ("lora", "vector", "constant", "none").
- `config_C`: Tipo de ruta para C ("lora", "vector", "none").
- `config_D_E`: Tipo de ruta para D y E ("constant", "vector", "none").
- `bias`: Manejo del sesgo (`"none"`, `"all"` o `"glora_only"`).
- `init_weights`: Si es `True` (valor predeterminado), GLoRA se inicializa como una operación sin efecto. Si es `False`, se utiliza la inicialización de kaiming.

Notas:
- `config_D_E` no admite `"lora"`.
- `target_modules` se puede omitir para los tipos de modelo compatibles (se usan las mapeaciones predeterminadas de PEFT).

## GloraModel[[peft.GloraModel]]

#### peft.GloraModel[[peft.GloraModel]]

```python
peft.GloraModel(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/glora/model.py#L34)

Crea un modelo Generalized Low Rank Adapter (GLoRA) a partir de un modelo de transformers preentrenado.

- Envuelve un modelo base e inyecta adaptadores GLoRA en los módulos especificados.
- Admite múltiples adaptadores, cambio de adaptadores, fusión/desfusión e inferencia con lotes mixtos.
- Use `set_adapter`, `merge_and_unload` y métodos relacionados para la gestión de adaptadores.

## GloraLayer y GloraLinear[[peft.tuners.glora.GloraLayer]]

#### peft.tuners.glora.GloraLayer[[peft.tuners.glora.GloraLayer]]

```python
peft.tuners.glora.GloraLayer(base_layer: nn.Module, **kwargs)
```

[Fuente](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/glora/layer.py#L103)

#### peft.tuners.glora.GloraLinear[[peft.tuners.glora.GloraLinear]]

```python
peft.tuners.glora.GloraLinear(base_layer: nn.Module, adapter_name: str, config, **kwargs)
```

[Fuente](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/glora/layer.py#L298)

Adaptador GLoRA que envuelve una `base_layer` densa `~torch.nn.Linear`.

- `GloraLayer` es la lógica central para la adaptación de bajo rango generalizada, con soporte para múltiples adaptadores y configuraciones de ruta flexibles.
- `GloraLinear` es un reemplazo directo para `nn.Linear` con soporte para GLoRA.
- GLoRA actualmente admite capas base `torch.nn.Linear` simples.

## Ejemplo de uso

```python
from transformers import AutoModelForCausalLM
from peft import GloraConfig, get_peft_model

model = AutoModelForCausalLM.from_pretrained("your-model-id")
glora_config = GloraConfig(
    r=8,
    target_modules=["q_proj", "v_proj"],
    config_A_B="lora",
    config_C="vector",
    config_D_E="constant",
    task_type="CAUSAL_LM",
)
model = get_peft_model(model, glora_config)
model.print_healthcheck()

# Switch adapters, merge, etc.
model.set_adapter("default")
model.merge_and_unload()
```

## Notas
- GLoRA es un superconjunto de LoRA: establecer todas las rutas en "lora" recupera el LoRA estándar.
- Puede usar diferentes tipos de ruta para A/B/C/D/E para experimentar con nuevas estrategias de adaptación.
- GLoRA admite todas las funciones estándar de gestión de adaptadores PEFT (agregar, eliminar, cambiar, fusionar, etc.).

## Véase también
- [Referencia de LoRA](./lora)
- [Artículo: https://huggingface.co/papers/2306.07967](https://huggingface.co/papers/2306.07967)

