PEFT documentation
Modelos personalizados
Modelos personalizados
Algunas técnicas de ajuste fino, como el prompt tuning, son específicas de los modelos de lenguaje. Esto significa que en 🤗 PEFT se asume que se está utilizando un modelo de 🤗 Transformers. Sin embargo, otras técnicas de ajuste fino, como LoRA, no están restringidas a tipos de modelos específicos.
En esta guía, veremos cómo se puede aplicar LoRA a una red neuronal multicapa, a un modelo de visión por computadora de la biblioteca timm o a una nueva arquitectura de 🤗 Transformers.
Perceptrón multicapa
Supongamos que queremos hacer un ajuste fino de un perceptrón multicapa con LoRA. Esta es la definición:
from torch import nn
class MLP(nn.Module):
def __init__(self, num_units_hidden=2000):
super().__init__()
self.seq = nn.Sequential(
nn.Linear(20, num_units_hidden),
nn.ReLU(),
nn.Linear(num_units_hidden, num_units_hidden),
nn.ReLU(),
nn.Linear(num_units_hidden, 2),
nn.LogSoftmax(dim=-1),
)
def forward(self, X):
return self.seq(X)Este es un perceptrón multicapa sencillo con una capa de entrada, una capa oculta y una capa de salida.
Para este ejemplo didáctico, elegimos un número de unidades ocultas extremadamente alto para resaltar las ganancias de eficiencia de PEFT, aunque esas ganancias son coherentes con ejemplos más realistas.
Hay algunas capas lineales en este modelo que podrían ajustarse con LoRA. Al trabajar con modelos comunes de 🤗 Transformers, PEFT sabe a qué capas aplicar LoRA, pero en este caso, corresponde al usuario elegir las capas. Para determinar los nombres de las capas a ajustar:
print([(n, type(m)) for n, m in MLP().named_modules()])Esto debería imprimir:
[('', __main__.MLP),
('seq', torch.nn.modules.container.Sequential),
('seq.0', torch.nn.modules.linear.Linear),
('seq.1', torch.nn.modules.activation.ReLU),
('seq.2', torch.nn.modules.linear.Linear),
('seq.3', torch.nn.modules.activation.ReLU),
('seq.4', torch.nn.modules.linear.Linear),
('seq.5', torch.nn.modules.activation.LogSoftmax)]Supongamos que queremos aplicar LoRA a la capa de entrada y a la capa oculta, que son 'seq.0' y 'seq.2'. Además,
supongamos que queremos actualizar la capa de salida sin LoRA, que sería 'seq.4'. La configuración correspondiente sería:
from peft import LoraConfig
config = LoraConfig(
target_modules=["seq.0", "seq.2"],
modules_to_save=["seq.4"],
)Con eso, podemos crear nuestro modelo PEFT y comprobar la fracción de parámetros entrenados:
from peft import get_peft_model
model = MLP()
peft_model = get_peft_model(model, config)
peft_model.print_healthcheck()Por último, podemos usar cualquier marco de entrenamiento que prefiramos, o escribir nuestro propio bucle de ajuste, para entrenar el peft_model.
Para un ejemplo completo, consulta este cuaderno.
modelos de timm
La biblioteca timm contiene una gran cantidad de modelos de visión por computadora preentrenados. También es posible realizar el ajuste fino de estos modelos con PEFT. Veamos cómo funciona esto en la práctica.
Para empezar, asegúrate de que timm esté instalado en el entorno de Python:
python -m pip install -U timm
A continuación, cargamos un modelo de timm para una tarea de clasificación de imágenes:
import timm
num_classes = ...
model_id = "timm/poolformer_m36.sail_in1k"
model = timm.create_model(model_id, pretrained=True, num_classes=num_classes)De nuevo, debemos decidir a qué capas aplicar LoRA. Dado que LoRA admite capas de convolución 2D y que estas son un bloque de construcción fundamental de este modelo, debemos aplicar LoRA a las capas de convolución 2D. Para identificar los nombres de esas capas, veamos todos los nombres de las capas:
print([(n, type(m)) for n, m in model.named_modules()])Esto imprimirá una lista muy larga, solo mostraremos las primeras:
[('', timm.models.metaformer.MetaFormer),
('stem', timm.models.metaformer.Stem),
('stem.conv', torch.nn.modules.conv.Conv2d),
('stem.norm', torch.nn.modules.linear.Identity),
('stages', torch.nn.modules.container.Sequential),
('stages.0', timm.models.metaformer.MetaFormerStage),
('stages.0.downsample', torch.nn.modules.linear.Identity),
('stages.0.blocks', torch.nn.modules.container.Sequential),
('stages.0.blocks.0', timm.models.metaformer.MetaFormerBlock),
('stages.0.blocks.0.norm1', timm.layers.norm.GroupNorm1),
('stages.0.blocks.0.token_mixer', timm.models.metaformer.Pooling),
('stages.0.blocks.0.token_mixer.pool', torch.nn.modules.pooling.AvgPool2d),
('stages.0.blocks.0.drop_path1', torch.nn.modules.linear.Identity),
('stages.0.blocks.0.layer_scale1', timm.models.metaformer.Scale),
('stages.0.blocks.0.res_scale1', torch.nn.modules.linear.Identity),
('stages.0.blocks.0.norm2', timm.layers.norm.GroupNorm1),
('stages.0.blocks.0.mlp', timm.layers.mlp.Mlp),
('stages.0.blocks.0.mlp.fc1', torch.nn.modules.conv.Conv2d),
('stages.0.blocks.0.mlp.act', torch.nn.modules.activation.GELU),
('stages.0.blocks.0.mlp.drop1', torch.nn.modules.dropout.Dropout),
('stages.0.blocks.0.mlp.norm', torch.nn.modules.linear.Identity),
('stages.0.blocks.0.mlp.fc2', torch.nn.modules.conv.Conv2d),
('stages.0.blocks.0.mlp.drop2', torch.nn.modules.dropout.Dropout),
('stages.0.blocks.0.drop_path2', torch.nn.modules.linear.Identity),
('stages.0.blocks.0.layer_scale2', timm.models.metaformer.Scale),
('stages.0.blocks.0.res_scale2', torch.nn.modules.linear.Identity),
('stages.0.blocks.1', timm.models.metaformer.MetaFormerBlock),
('stages.0.blocks.1.norm1', timm.layers.norm.GroupNorm1),
('stages.0.blocks.1.token_mixer', timm.models.metaformer.Pooling),
('stages.0.blocks.1.token_mixer.pool', torch.nn.modules.pooling.AvgPool2d),
...
('head.global_pool.flatten', torch.nn.modules.linear.Identity),
('head.norm', timm.layers.norm.LayerNorm2d),
('head.flatten', torch.nn.modules.flatten.Flatten),
('head.drop', torch.nn.modules.linear.Identity),
('head.fc', torch.nn.modules.linear.Linear)]
]Al examinarlo con más detalle, vemos que las capas de convolución 2D tienen nombres como "stages.0.blocks.0.mlp.fc1" y "stages.0.blocks.0.mlp.fc2". ¿Cómo podemos hacer coincidir esos nombres de capa específicamente? Puedes escribir una expresión regular para hacer coincidir los nombres de las capas. En nuestro caso, la expresión regular r".*\.mlp\.fc\d" debería ser suficiente.
Además, como en el primer ejemplo, debemos asegurarnos de que la capa de salida, en este caso la cabeza de clasificación, también se actualice. Mirando el final de la lista impresa anteriormente, podemos ver que se llama 'head.fc'. Con eso en mente, aquí está nuestra configuración de LoRA:
config = LoraConfig(target_modules=r".*\.mlp\.fc\d", modules_to_save=["head.fc"])Luego solo necesitamos crear el modelo PEFT pasando nuestro modelo base y la configuración a get_peft_model:
peft_model = get_peft_model(model, config) peft_model.print_healthcheck()
Esto nos muestra que solo necesitamos entrenar menos del 2% de todos los parámetros, lo que supone una gran ganancia de eficiencia.
Para un ejemplo completo, consulta este cuaderno.
Nuevas arquitecturas de transformers
Cuando se publican nuevas arquitecturas populares de transformers, hacemos todo lo posible por añadirlas rápidamente a PEFT. Si encuentras un modelo de transformers que no está soportado de forma nativa, no te preocupes, es muy probable que funcione si la configuración está establecida correctamente. En concreto, debes identificar las capas que deben adaptarse y configurarlas correctamente al inicializar la clase de configuración correspondiente, por ejemplo, LoraConfig. Aquí tienes algunos consejos para ayudarte con esto.
Como primer paso, es buena idea revisar los modelos existentes para buscar inspiración. Puedes encontrarlos dentro de constants.py en el repositorio de PEFT. A menudo, encontrarás una arquitectura similar que utiliza los mismos nombres. Por ejemplo, si la nueva arquitectura del modelo es una variación del modelo “mistral” y quieres aplicar LoRA, puedes ver que la entrada para “mistral” en TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING contiene ["q_proj", "v_proj"]. Esto te indica que, para los modelos “mistral”, los target_modules para LoRA deben ser ["q_proj", "v_proj"]:
from peft import LoraConfig, get_peft_model
my_mistral_model = ...
config = LoraConfig(
target_modules=["q_proj", "v_proj"],
..., # other LoRA arguments
)
peft_model = get_peft_model(my_mistral_model, config)Si eso no ayuda, comprueba los módulos existentes en la arquitectura de tu modelo con el método named_modules e intenta identificar las capas de atención, especialmente las capas de clave, consulta y valor. Estas suelen tener nombres como c_attn, query, q_proj, etc. La capa de clave no siempre se adapta, e idealmente, debes comprobar si incluirla resulta en un mejor rendimiento.
Además, las capas lineales son objetivos habituales para la adaptación (por ejemplo, en el artículo de QLoRA, los autores sugieren adaptarlas también). Sus nombres suelen contener las cadenas fc o dense.
Si deseas añadir un nuevo modelo a PEFT, crea una entrada en constants.py y abre una pull request en el repositorio. No olvides actualizar también el README.
Verificar parámetros y capas
Puedes verificar si has aplicado correctamente un método PEFT a tu modelo de varias maneras.
- Ejecute print_healthcheck() para inspeccionar la fracción de parámetros entrenables y el estado del adaptador. Si la fracción de parámetros es menor o mayor de lo esperado, verifique la
reprdel modelo imprimiéndolo. Esto muestra los nombres de todos los tipos de capas en el modelo. Asegúrese de que solo las capas objetivo previstas sean reemplazadas por las capas del adaptador. Por ejemplo, si LoRA se aplica a capasnn.Linear, entonces solo debería ver capaslora.Linearen uso.
peft_model.print_healthcheck()
- Otra forma de ver las capas adaptadas es usar el atributo
targeted_module_namespara listar el nombre de cada módulo que fue adaptado.
print(peft_model.targeted_module_names)Tipos de módulos no admitidos
Métodos como LoRA solo funcionan si los módulos objetivo son compatibles con PEFT. Por ejemplo, es posible aplicar LoRA a las capas nn.Linear y nn.Conv2d, pero no, por ejemplo, a nn.LSTM. Si encuentras una clase de capa a la que deseas aplicar PEFT y no es compatible, puedes:
- define un mapeo personalizado para despachar dinámicamente módulos personalizados en LoRA
- abrir un issue y solicitar la función, donde los mantenedores la implementarán o te guiarán sobre cómo implementarla tú mismo si la demanda de este tipo de módulo es lo suficientemente alta
Soporte experimental para despacho dinámico de módulos personalizados en LoRA
Esta función es experimental y está sujeta a cambios, dependiendo de su recepción por parte de la comunidad. Introduciremos una API pública y estable si existe una demanda significativa al respecto.
PEFT admite una API experimental para tipos de módulos personalizados para LoRA. Supongamos que tienes una implementación de LoRA para LSTMs. Normalmente, no podrías indicarle a PEFT que la utilice, incluso si teóricamente funcionaría con PEFT. Sin embargo, esto es posible mediante la asignación dinámica de capas personalizadas.
La API experimental actualmente se ve así:
class MyLoraLSTMLayer:
...
base_model = ... # load the base model that uses LSTMs
# add the LSTM layer names to target_modules
config = LoraConfig(..., target_modules=["lstm"])
# define a mapping from base layer type to LoRA layer type
custom_module_mapping = {nn.LSTM: MyLoraLSTMLayer}
# register the new mapping
config._register_custom_module(custom_module_mapping)
# after registration, create the PEFT model
peft_model = get_peft_model(base_model, config)
# do trainingCuando llamas a get_peft_model(), verás una advertencia porque PEFT no reconoce el tipo de módulo objetivo. En este caso, puedes ignorar esta advertencia.
Al proporcionar un mapeo personalizado, PEFT primero comprueba las capas del modelo base contra el mapeo personalizado y deriva al tipo de capa LoRA personalizada si hay una coincidencia. Si no hay coincidencia, PEFT comprueba los tipos de capa LoRA integrados para buscar una coincidencia.
Por lo tanto, esta función también se puede utilizar para sobrescribir la lógica de despacho existente, por ejemplo, si desea usar su propia capa LoRA para nn.Linear en lugar de la proporcionada por PEFT.
Al crear tu módulo LoRA personalizado, sigue las mismas reglas que los módulos LoRA existentes. Algunas restricciones importantes a considerar:
- El módulo personalizado debe heredar de
nn.Moduleypeft.tuners.lora.layer.LoraLayer. - El método
__init__del módulo personalizado debe tener los argumentos posicionalesbase_layeryadapter_name. Después de estos, hay**kwargsadicionales que puedes usar o ignorar libremente. - Los parámetros aprendibles deben almacenarse en un
nn.ModuleDictonn.ParameterDict, donde la clave corresponde al nombre del adaptador específico (recuerde que un modelo puede tener más de un adaptador a la vez). - El nombre de estos atributos de parámetros aprendibles debe comenzar con
"lora_", por ejemplo,self.lora_new_param = .... - Algunos métodos son opcionales, por ejemplo, solo necesitas implementar
mergeyunmergesi quieres admitir la fusión de pesos.
Actualmente, la información sobre el módulo personalizado no se conserva al guardar el modelo. Al cargar el modelo, es necesario registrar los módulos personalizados de nuevo.
# saving works as always and includes the parameters of the custom modules
peft_model.save_pretrained(<model-path>)
# loading the model later:
base_model = ...
# load the LoRA config that you saved earlier
config = LoraConfig.from_pretrained(<model-path>)
# register the custom module again, the same way as the first time
custom_module_mapping = {nn.LSTM: MyLoraLSTMLayer}
config._register_custom_module(custom_module_mapping)
# pass the config instance to from_pretrained:
peft_model = PeftModel.from_pretrained(model, tmp_path / "lora-custom-module", config=config)Si usas esta función y la encuentras útil, o si te encuentras con problemas, infórmalo creando un issue o una discusión en GitHub. Esto nos permite estimar la demanda de esta función y añadir una API pública si es lo suficientemente alta.
Update on GitHub