From 03a1a7d2c0b00ecfde6f4b9c3c19b68ae341b5d7 Mon Sep 17 00:00:00 2001 From: Nicholas Jackman Date: Mon, 29 Apr 2024 11:51:42 -0700 Subject: [PATCH 1/3] translated peft es and toctree.yml add --- docs/source/es/_toctree.yml | 2 + docs/source/es/peft.md | 238 ++++++++++++++++++++++++++++++++++++ 2 files changed, 240 insertions(+) create mode 100644 docs/source/es/peft.md diff --git a/docs/source/es/_toctree.yml b/docs/source/es/_toctree.yml index cf1ae39c03077e..3eb2032ec82192 100644 --- a/docs/source/es/_toctree.yml +++ b/docs/source/es/_toctree.yml @@ -96,6 +96,8 @@ title: Mecanismos de atención - local: pad_truncation title: Relleno y truncamiento + local: peft + title: Carga los adaptadores con 🤗 PEFT - local: bertology title: BERTología - local: perplexity diff --git a/docs/source/es/peft.md b/docs/source/es/peft.md new file mode 100644 index 00000000000000..35415b9b06675d --- /dev/null +++ b/docs/source/es/peft.md @@ -0,0 +1,238 @@ + + +# Carga los adaptadores con 🤗 PEFT + +[[open-in-colab]] + +[Parameter-Efficient Fine Tuning (PEFT)](https://huggingface.co/blog/peft) métodos congelan los parámetros del modelo preentrenado durante el afinamiento y agregan un pequeño número de parámetros entrenables (los adaptadores) encima de eso. Varios parámetros entrenables (los adaptadores) están entrenados para aprender la tarea específica. Está manera a sido comprobada en ser eficiente con la memoria y con menos uso de computar mientras produciendo resultados comparable a un modelo completamente afinado. + + Adaptadores entrenados con PEFT también son usualmente un orden de magnitud más pequeños que los modelos enteros, haciéndolos más convenientes para compartir, archivar, y cargar. + +
+ +
The adapter weights for a OPTForCausalLM model stored on the Hub are only ~6MB compared to the full size of the model weights, which can be ~700MB.
+
+ +Si estás interesado en aprender más sobre la librería de PEFT, lee la [documentación](https://huggingface.co/docs/peft/index). + +## Configuración + +Empezar por instalar 🤗 PEFT: + +```bash +pip install peft +``` + +Si quieres tratar las nuevas características, instala la librería de la fuente: + +```bash +pip install git+https://github.com/huggingface/peft.git +``` + +## Los modelos de PEFT apoyados + +Los 🤗 Transformers nativamente apoyan algunos métodos de PEFT. De esta manera puedes cargar los pesos del adaptador archivados localmente o archivados en el Hub y fácilmente ejecutar o entrenar los pesos con unas cuantas líneas de código. Los siguientes métodos están apoyados: + +- [Low Rank Adapters](https://huggingface.co/docs/peft/conceptual_guides/lora) +- [IA3](https://huggingface.co/docs/peft/conceptual_guides/ia3) +- [AdaLoRA](https://arxiv.org/abs/2303.10512) + +Si quieres usar otros métodos de PEFT como el aprendizaje de avisos o afinamientos de los avisos o de la librería de 🤗 PEFT en general por favor refiere a la [documentación](https://huggingface.co/docs/peft/index). + + +## Cargar un adaptador de PEFT + +Para cargar y usar un modelo adaptador de PEFT desde 🤗 Transformers, asegura que el Hub repositorio o el directorio local contiene un `adapter_config.json` archivo y pesas de adaptadores como presentado en el imagen de arriba. Después puedes cargar el modelo adaptador de PEFT usando la clase de `AutoModelFor`. Por ejemplo, para cargar el modelo adaptador de PEFT para modelar usando idioma casual: + +1. específica el ID del modelo de PEFT +2. pásalo a la clase de [`AutoModelForCausalLM`] + +```py +from transformers import AutoModelForCausalLM, AutoTokenizer + +peft_model_id = "ybelkada/opt-350m-lora" +model = AutoModelForCausalLM.from_pretrained(peft_model_id) +``` + + + +Puedes cargar al PEFT adaptador con una clase de `AutoModelFor` o la clase del modelo base como `OPTForCausalLM` o `LlamaForCausalLM`. + + + +Tambíen puedes cargar un adaptador de PEFT llamando el método de `load_adapter`: + +```py +from transformers import AutoModelForCausalLM, AutoTokenizer + +model_id = "facebook/opt-350m" +peft_model_id = "ybelkada/opt-350m-lora" + +model = AutoModelForCausalLM.from_pretrained(model_id) +model.load_adapter(peft_model_id) +``` + +## Cargar en 8bit o 4bit + +La integración de `bitsandbytes` apoya los tipos de datos precisos que son utilizados para cargar modelos grandes porque + guarda memoria (mira la [guia](./quantization#bitsandbytes-integration) de `bitsandbytes` para aprender mas). Agrega el parametro `load_in_8bit` o el parametro `load_in_4bit` al [`~PreTrainedModel.from_pretrained`] y coloca `device_map="auto"` para effectivamente distribuir el modelo tu hardware: + +```py +from transformers import AutoModelForCausalLM, AutoTokenizer + +peft_model_id = "ybelkada/opt-350m-lora" +model = AutoModelForCausalLM.from_pretrained(peft_model_id, device_map="auto", load_in_8bit=True) +``` + +## Agrega un nuevo adaptador + +Puedes usar [`~peft.PeftModel.add_adapter`] para agregar un nuevo adaptador a un modelo con un existente adaptador mientras + el nuevo sea el mismo tipo que el adaptador actual. Por ejemplo si tienes un existente LoRA adaptador ajunto a un modelo: + +```py +from transformers import AutoModelForCausalLM, OPTForCausalLM, AutoTokenizer +from peft import LoraConfig + +model_id = "facebook/opt-350m" +model = AutoModelForCausalLM.from_pretrained(model_id), +lora_config = LoraConfig( + target_modules=["q_proj", "k_proj"], + init_lora_weights=False +) + +model.add_adapter(lora_config, adapter_name="adapter_1") +``` + +Para agregar un nuevo adaptador: + +```py +# attach new adapter with same config +model.add_adapter(lora_config, adapter_name="adapter_2") +``` + +Ahora puedes usar [`~peft.PeftModel.set_adapter`] para configurar cuál adaptador para usar: + +```py +# use adapter_1 +model.set_adapter("adapter_1") +output = model.generate(**inputs) +print(tokenizer.decode(output_disabled[0], skip_special_tokens=True)) + +# use adapter_2 +model.set_adapter("adapter_2") +output_enabled = model.generate(**inputs) +print(tokenizer.decode(output_enabled[0], skip_special_tokens=True)) +``` + +## Para activar y desactivar los adaptadores + +Cuando has agregado un adaptador a un modelo, activa or desactiva el módulo de adaptador. Para activar el módulo de adaptador: + +```py +from transformers import AutoModelForCausalLM, OPTForCausalLM, AutoTokenizer +from peft import PeftConfig + +model_id = "facebook/opt-350m" +adapter_model_id = "ybelkada/opt-350m-lora" +tokenizer = AutoTokenizer.from_pretrained(model_id) +text = "Hello" +inputs = tokenizer(text, return_tensors="pt") + +model = AutoModelForCausalLM.from_pretrained(model_id) +peft_config = PeftConfig.from_pretrained(adapter_model_id) + +# to initiate with random weights +peft_config.init_lora_weights = False + +model.add_adapter(peft_config) +model.enable_adapters() +output = model.generate(**inputs) +``` + +Para desactivar el modulo adaptero: + +```py +model.disable_adapters() +output = model.generate(**inputs) +``` + +## Como entrenar un adaptor de PEFT + +Los adaptadores de PEFT están apoyados por la clase de PEFT [`Trainer`] para que puedas entrenar el adaptador para tu caso de uso específico. Sólo requiere agregar unas cuantas líneas más de código. Por ejemplo, para entrenar un adaptador de LoRA: + + + +Si no estás familiarizado con el proceso de afinar un modelo con [`Trainer`], mira el tutorial [Fine-tune a pretrained model](training). + + + +1. Define tu configuraciôn de adaptador con el tipo de tarea y hiperparámetros (lee [`~peft.LoraConfig`] sobre más detalles de lo que + hacen los hiperparámetros). + +```py +from peft import LoraConfig + +peft_config = LoraConfig( + lora_alpha=16, + lora_dropout=0.1, + r=64, + bias="none", + task_type="CAUSAL_LM", +) +``` + +2. Agrega el adaptador al modelo. + +```py +model.add_adapter(peft_config) +``` + +3. ¡Ahora puedes pasar el modelo a [`Trainer`]! + +```py +trainer = Trainer(model=model, ...) +trainer.train() +``` + +Para archivar tu adaptador entrenado y volver a cargarlo: + +```py +model.save_pretrained(save_dir) +model = AutoModelForCausalLM.from_pretrained(save_dir) +``` + +## Agrega capas entrenables adicionales a un PEFT adaptador + +Tambien puedes afinar adaptadores entrenables adicionales en encima de un modelo que tiene adaptadores ajustados por pasar a `modules_to_save` en tu config PEFT. Por ejemplo, si tu quieres también afinar el lm_head encima de un modelo con un adaptador de LoRA: + +```py +from transformers import AutoModelForCausalLM, OPTForCausalLM, AutoTokenizer +from peft import LoraConfig + +model_id = "facebook/opt-350m" +model = AutoModelForCausalLM.from_pretrained(model_id) + +lora_config = LoraConfig( + target_modules=["q_proj", "k_proj"], + modules_to_save=["lm_head"], +) + +model.add_adapter(lora_config) +``` + + + From a7e68e80c0c1642a4e46b6675edbcebb8c2735fa Mon Sep 17 00:00:00 2001 From: Nicholas Jackman Date: Tue, 14 May 2024 22:48:45 -0700 Subject: [PATCH 2/3] updated yml and peft translation --- docs/source/es/_toctree.yml | 4 ++-- docs/source/es/peft.md | 34 +++++++++++++++++----------------- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/docs/source/es/_toctree.yml b/docs/source/es/_toctree.yml index 3eb2032ec82192..12a1bbd0ec4d63 100644 --- a/docs/source/es/_toctree.yml +++ b/docs/source/es/_toctree.yml @@ -17,6 +17,8 @@ title: Fine-tuning a un modelo pre-entrenado - local: accelerate title: Entrenamiento distribuido con 🤗 Accelerate + local: peft + title: Carga los adaptadores con 🤗 PEFT - local: model_sharing title: Compartir un modelo title: Tutoriales @@ -96,8 +98,6 @@ title: Mecanismos de atención - local: pad_truncation title: Relleno y truncamiento - local: peft - title: Carga los adaptadores con 🤗 PEFT - local: bertology title: BERTología - local: perplexity diff --git a/docs/source/es/peft.md b/docs/source/es/peft.md index 35415b9b06675d..88b730ece63018 100644 --- a/docs/source/es/peft.md +++ b/docs/source/es/peft.md @@ -13,16 +13,16 @@ rendered properly in your Markdown viewer. [[open-in-colab]] -[Parameter-Efficient Fine Tuning (PEFT)](https://huggingface.co/blog/peft) métodos congelan los parámetros del modelo preentrenado durante el afinamiento y agregan un pequeño número de parámetros entrenables (los adaptadores) encima de eso. Varios parámetros entrenables (los adaptadores) están entrenados para aprender la tarea específica. Está manera a sido comprobada en ser eficiente con la memoria y con menos uso de computar mientras produciendo resultados comparable a un modelo completamente afinado. +[Parameter-Efficient Fine Tuning (PEFT)](https://huggingface.co/blog/peft) métodos congelan los parámetros del modelo preentrenado durante el punto fino y agregan un pequeño número de parámetros entrenables (los adaptadores) encima de eso. Los parámetros (los adaptadores) están entrenados para aprender la información tarea específica. Este enfoque a sido comprobado en ser muy eficiente en memoria con proceso inferior mientras produciendo resultados comparable a un modelo completamente afinado. Adaptadores entrenados con PEFT también son usualmente un orden de magnitud más pequeños que los modelos enteros, haciéndolos más convenientes para compartir, archivar, y cargar.
-
The adapter weights for a OPTForCausalLM model stored on the Hub are only ~6MB compared to the full size of the model weights, which can be ~700MB.
+
Los pesos del adaptero para un modelo de OPTForCausalLM guardado en el Hub son solo ~6MB en comparaciôn al tamaño completo de los pesos de modelo, cuales sean ~700MB.
-Si estás interesado en aprender más sobre la librería de PEFT, lee la [documentación](https://huggingface.co/docs/peft/index). +Si estás interesado en aprender más sobre la librería de PEFT, mira la [documentación](https://huggingface.co/docs/peft/index). ## Configuración @@ -40,18 +40,18 @@ pip install git+https://github.com/huggingface/peft.git ## Los modelos de PEFT apoyados -Los 🤗 Transformers nativamente apoyan algunos métodos de PEFT. De esta manera puedes cargar los pesos del adaptador archivados localmente o archivados en el Hub y fácilmente ejecutar o entrenar los pesos con unas cuantas líneas de código. Los siguientes métodos están apoyados: +Los 🤗 Transformers nativamente apoyan algunos métodos de PEFT, que significa puedes cargar los pesos del adaptador archivados localmente o archivados en el Hub y fácilmente ejecutar o entrenar los pesos con unas cuantas líneas de código. Los siguientes métodos están apoyados: - [Low Rank Adapters](https://huggingface.co/docs/peft/conceptual_guides/lora) - [IA3](https://huggingface.co/docs/peft/conceptual_guides/ia3) - [AdaLoRA](https://arxiv.org/abs/2303.10512) -Si quieres usar otros métodos de PEFT como el aprendizaje de avisos o afinamientos de los avisos o de la librería de 🤗 PEFT en general por favor refiere a la [documentación](https://huggingface.co/docs/peft/index). +Si quieres usar otros métodos de PEFT como el aprendizaje de los prompts o afinamientos de los prompts o de la librería de 🤗 PEFT en general, por favor refiere a la [documentación](https://huggingface.co/docs/peft/index). ## Cargar un adaptador de PEFT -Para cargar y usar un modelo adaptador de PEFT desde 🤗 Transformers, asegura que el Hub repositorio o el directorio local contiene un `adapter_config.json` archivo y pesas de adaptadores como presentado en el imagen de arriba. Después puedes cargar el modelo adaptador de PEFT usando la clase de `AutoModelFor`. Por ejemplo, para cargar el modelo adaptador de PEFT para modelar usando idioma casual: +Para cargar y usar un modelo adaptador de PEFT desde 🤗 Transformers, asegura que el Hub repositorio o el directorio local contiene un `adapter_config.json` archivo y pesas de adaptadores como presentado en el ejemplo de imagen de arriba. Después puedes cargar el modelo adaptador de PEFT usando la clase de `AutoModelFor`. Por ejemplo, para cargar el modelo adaptador de PEFT para el lenguaje casual en modelar: 1. específica el ID del modelo de PEFT 2. pásalo a la clase de [`AutoModelForCausalLM`] @@ -65,7 +65,7 @@ model = AutoModelForCausalLM.from_pretrained(peft_model_id) -Puedes cargar al PEFT adaptador con una clase de `AutoModelFor` o la clase del modelo base como `OPTForCausalLM` o `LlamaForCausalLM`. +Puedes cargar al PEFT adaptador con tampoco una clase de `AutoModelFor` o la clase del modelo base como `OPTForCausalLM` o `LlamaForCausalLM`. @@ -83,8 +83,8 @@ model.load_adapter(peft_model_id) ## Cargar en 8bit o 4bit -La integración de `bitsandbytes` apoya los tipos de datos precisos que son utilizados para cargar modelos grandes porque - guarda memoria (mira la [guia](./quantization#bitsandbytes-integration) de `bitsandbytes` para aprender mas). Agrega el parametro `load_in_8bit` o el parametro `load_in_4bit` al [`~PreTrainedModel.from_pretrained`] y coloca `device_map="auto"` para effectivamente distribuir el modelo tu hardware: +La integración de `bitsandbytes` apoya los tipos de datos precisos que son útiles para cargar modelos grandes porque + guarda memoria (mira la [guia](https://huggingface.co/docs/transformers/quantization#bitsandbyes) de `bitsandbytes` para aprender mas). Agrega el parametro `load_in_8bit` o el parametro `load_in_4bit` al [`~PreTrainedModel.from_pretrained`] y coloca `device_map="auto"` para effectivamente distribuir el modelo en tu hardware: ```py from transformers import AutoModelForCausalLM, AutoTokenizer @@ -95,8 +95,8 @@ model = AutoModelForCausalLM.from_pretrained(peft_model_id, device_map="auto", l ## Agrega un nuevo adaptador -Puedes usar [`~peft.PeftModel.add_adapter`] para agregar un nuevo adaptador a un modelo con un existente adaptador mientras - el nuevo sea el mismo tipo que el adaptador actual. Por ejemplo si tienes un existente LoRA adaptador ajunto a un modelo: +Puedes usar [`~peft.PeftModel.add_adapter`] para agregar un nuevo adaptador a un modelo con un existente adaptador con tal que + el nuevo sea el mismo tipo que el adaptador actual. Por ejemplo si tienes un existente LoRA adaptador connectado a un modelo: ```py from transformers import AutoModelForCausalLM, OPTForCausalLM, AutoTokenizer @@ -135,7 +135,7 @@ print(tokenizer.decode(output_enabled[0], skip_special_tokens=True)) ## Para activar y desactivar los adaptadores -Cuando has agregado un adaptador a un modelo, activa or desactiva el módulo de adaptador. Para activar el módulo de adaptador: +Cuando has agregado un adaptador a un modelo, puedes activar or desactivar el módulo de adaptador. Para activar el módulo de adaptador: ```py from transformers import AutoModelForCausalLM, OPTForCausalLM, AutoTokenizer @@ -165,17 +165,17 @@ model.disable_adapters() output = model.generate(**inputs) ``` -## Como entrenar un adaptor de PEFT +## Entrenar un adaptor de PEFT -Los adaptadores de PEFT están apoyados por la clase de PEFT [`Trainer`] para que puedas entrenar el adaptador para tu caso de uso específico. Sólo requiere agregar unas cuantas líneas más de código. Por ejemplo, para entrenar un adaptador de LoRA: +Los adaptadores de PEFT están apoyados por la clase de [`Trainer`] para que puedas entrenar el adaptador para tu caso de uso específico. Sólo requiere agregar unas líneas más de código. Por ejemplo, para entrenar un adaptador de LoRA: -Si no estás familiarizado con el proceso de afinar un modelo con [`Trainer`], mira el tutorial [Fine-tune a pretrained model](training). +Si no estás familiarizado con el afinamiento de un modelo con la clase[`Trainer`], mira el tutorial [Fine-tune a pretrained model](training). -1. Define tu configuraciôn de adaptador con el tipo de tarea y hiperparámetros (lee [`~peft.LoraConfig`] sobre más detalles de lo que +1. Define tu configuraciôn de adaptador con el tipo de tarea y hiperparámetros (ves [`~peft.LoraConfig`] para más detalles de lo que hacen los hiperparámetros). ```py @@ -212,7 +212,7 @@ model = AutoModelForCausalLM.from_pretrained(save_dir) ## Agrega capas entrenables adicionales a un PEFT adaptador -Tambien puedes afinar adaptadores entrenables adicionales en encima de un modelo que tiene adaptadores ajustados por pasar a `modules_to_save` en tu config PEFT. Por ejemplo, si tu quieres también afinar el lm_head encima de un modelo con un adaptador de LoRA: +Tambien puedes afinar adaptadores entrenables adicionales en encima de un modelo que tiene adaptadores connectados por pasar a `modules_to_save` en tu config de PEFT. Por ejemplo, si tu quieres también afinar el lm_head encima de un modelo con un adaptador de LoRA: ```py from transformers import AutoModelForCausalLM, OPTForCausalLM, AutoTokenizer From 98e6061db9696a9f6ba716725586773dae74eadc Mon Sep 17 00:00:00 2001 From: Nicholas Jackman Date: Thu, 20 Jun 2024 15:33:50 -0700 Subject: [PATCH 3/3] redid peft.md es translate after notes --- docs/source/es/peft.md | 107 +++++++++++++++++++++++------------------ 1 file changed, 60 insertions(+), 47 deletions(-) diff --git a/docs/source/es/peft.md b/docs/source/es/peft.md index 88b730ece63018..91768520b43607 100644 --- a/docs/source/es/peft.md +++ b/docs/source/es/peft.md @@ -1,60 +1,60 @@ -# Carga los adaptadores con 🤗 PEFT +# Cargar adaptadores con 🤗 PEFT [[open-in-colab]] -[Parameter-Efficient Fine Tuning (PEFT)](https://huggingface.co/blog/peft) métodos congelan los parámetros del modelo preentrenado durante el punto fino y agregan un pequeño número de parámetros entrenables (los adaptadores) encima de eso. Los parámetros (los adaptadores) están entrenados para aprender la información tarea específica. Este enfoque a sido comprobado en ser muy eficiente en memoria con proceso inferior mientras produciendo resultados comparable a un modelo completamente afinado. +Los metodos de afinamiento eficiente en parametros (PEFT, por sus siglas en ingles) congelan los parametros del modelo preentrenado durante el afinamiento y agregan un pequeno numero de parametros entrenables (los adaptadores) encima. Los adaptadores estan entrenados para aprender informacion especifica de una tarea. Este enfoque ha demostrado ser muy eficiente en memoria, con un menor uso de recursos computacionales, al mismo tiempo que produce resultados comparables a los de un modelo completamente ajustado. - Adaptadores entrenados con PEFT también son usualmente un orden de magnitud más pequeños que los modelos enteros, haciéndolos más convenientes para compartir, archivar, y cargar. +Los adaptadores entrenados con PEFT tambien suelen ser un orden de magnitud mas pequenos que el modelo completo, lo que facilita compartirlos, almacenarlos y cargarlos.
-
Los pesos del adaptero para un modelo de OPTForCausalLM guardado en el Hub son solo ~6MB en comparaciôn al tamaño completo de los pesos de modelo, cuales sean ~700MB.
+
Los pesos del adaptador para un modelo OPTForCausalLM almacenado en el Hub son solo de ~6MB en comparacion con el tamano completo de los pesos del modelo, que puede ser de ~700MB.
-Si estás interesado en aprender más sobre la librería de PEFT, mira la [documentación](https://huggingface.co/docs/peft/index). +Si esta interesado en aprender mas sobre la biblioteca de 🤗 PEFT, consulte la documentacion. ## Configuración -Empezar por instalar 🤗 PEFT: +Vamos a empezar instalando 🤗 PEFT: ```bash pip install peft ``` -Si quieres tratar las nuevas características, instala la librería de la fuente: +Si quiere probar las nuevas caracteristicas, es posible que le interese instalar la biblioteca desde la fuente: ```bash pip install git+https://github.com/huggingface/peft.git ``` +## Modelos PEFT admitidos -## Los modelos de PEFT apoyados +🤗 Transformers admite nativamente algunos metodos de PEFT. De esta manera puedes cargar los pesos del adaptador almacenados localmente o almacenados en el Hub y facilmente ejecutar o entrenar los pesos con unas cuantas lineas de codigo. Se cuenta con soporte para los siguientes metodos: -Los 🤗 Transformers nativamente apoyan algunos métodos de PEFT, que significa puedes cargar los pesos del adaptador archivados localmente o archivados en el Hub y fácilmente ejecutar o entrenar los pesos con unas cuantas líneas de código. Los siguientes métodos están apoyados: - [Low Rank Adapters](https://huggingface.co/docs/peft/conceptual_guides/lora) - [IA3](https://huggingface.co/docs/peft/conceptual_guides/ia3) - [AdaLoRA](https://arxiv.org/abs/2303.10512) -Si quieres usar otros métodos de PEFT como el aprendizaje de los prompts o afinamientos de los prompts o de la librería de 🤗 PEFT en general, por favor refiere a la [documentación](https://huggingface.co/docs/peft/index). +Si desea utilizar otros metodos PEFT, como el aprendizaje de indicaciones (prompt learning) o el ajuste de indicaciones (prompt tuning), o aprender mas sobre la biblioteca de 🤗 PEFT en general, consulte la [documentación](https://huggingface.co/docs/peft/index). +## Cargar un adaptador PEFT -## Cargar un adaptador de PEFT -Para cargar y usar un modelo adaptador de PEFT desde 🤗 Transformers, asegura que el Hub repositorio o el directorio local contiene un `adapter_config.json` archivo y pesas de adaptadores como presentado en el ejemplo de imagen de arriba. Después puedes cargar el modelo adaptador de PEFT usando la clase de `AutoModelFor`. Por ejemplo, para cargar el modelo adaptador de PEFT para el lenguaje casual en modelar: +Para cargar y utilizar un modelo adaptador PEFT desde 🤗 Transformers, asegurese de que el repositorio en el Hub o el directorio local contenga un archivo `adapter_config.json` y los pesos del adaptador, como se muestra en la imagen del ejemplo anterior. Luego, puede cargar el modelo adaptador PEFT usando la clase `AutoModelFor`. Por ejemplo, para cargar un modelo adaptador PEFT para modelado de lenguaje causal: -1. específica el ID del modelo de PEFT -2. pásalo a la clase de [`AutoModelForCausalLM`] +1. Especifique el ID del modelo PEFT +2. Paselo a la clase [`AutoModelForCausalLM`] ```py from transformers import AutoModelForCausalLM, AutoTokenizer @@ -65,11 +65,11 @@ model = AutoModelForCausalLM.from_pretrained(peft_model_id) -Puedes cargar al PEFT adaptador con tampoco una clase de `AutoModelFor` o la clase del modelo base como `OPTForCausalLM` o `LlamaForCausalLM`. +Puede cargar un adaptador PEFT con una clase AutoModelFor o con la clase del modelo base, como OPTForCausalLM o LlamaForCausalLM. -Tambíen puedes cargar un adaptador de PEFT llamando el método de `load_adapter`: +Tambien puede cargar un adaptador PEFT llamando al metodo `load_adapter`: ```py from transformers import AutoModelForCausalLM, AutoTokenizer @@ -81,29 +81,30 @@ model = AutoModelForCausalLM.from_pretrained(model_id) model.load_adapter(peft_model_id) ``` -## Cargar en 8bit o 4bit +Consulte la seccion de documentacion de API (#transformers.integrations.PeftAdapterMixin) a continuacion para mas detalles. -La integración de `bitsandbytes` apoya los tipos de datos precisos que son útiles para cargar modelos grandes porque - guarda memoria (mira la [guia](https://huggingface.co/docs/transformers/quantization#bitsandbyes) de `bitsandbytes` para aprender mas). Agrega el parametro `load_in_8bit` o el parametro `load_in_4bit` al [`~PreTrainedModel.from_pretrained`] y coloca `device_map="auto"` para effectivamente distribuir el modelo en tu hardware: +##Cargar en 8 bits o 4 bits + +La integracion `bitsandbytes` soporta tipos de datos de precisión de 8 bits y 4 bits, los cuales son utiles para cargar modelos grandes porque ahorran memoria (consulta la [guia de integracion bitsandbytes](./quantization#bitsandbytes-integration) para aprender mas). Anada los parametros `load_in_8bit` o `load_in_4bit` a [`~PreTrainedModel.from_pretrained`] y establezca `device_map="auto"` para distribuir efectivamente el modelo en su hardware: ```py -from transformers import AutoModelForCausalLM, AutoTokenizer +from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig peft_model_id = "ybelkada/opt-350m-lora" -model = AutoModelForCausalLM.from_pretrained(peft_model_id, device_map="auto", load_in_8bit=True) +model = AutoModelForCausalLM.from_pretrained(peft_model_id, quantization_config=BitsAndBytesConfig(load_in_8bit=True)) ``` -## Agrega un nuevo adaptador +## Agregar un nuevo adaptador -Puedes usar [`~peft.PeftModel.add_adapter`] para agregar un nuevo adaptador a un modelo con un existente adaptador con tal que - el nuevo sea el mismo tipo que el adaptador actual. Por ejemplo si tienes un existente LoRA adaptador connectado a un modelo: +Puede usar [`~peft.PeftModel.add_adapter`] para agregar un nuevo adaptador a un modelo con un adaptador existente siempre y cuando el nuevo adaptador sea del mismo tipo que el actual. Por ejemplo, si tiene un adaptador LoRA existente conectado a un modelo: ```py from transformers import AutoModelForCausalLM, OPTForCausalLM, AutoTokenizer from peft import LoraConfig model_id = "facebook/opt-350m" -model = AutoModelForCausalLM.from_pretrained(model_id), +model = AutoModelForCausalLM.from_pretrained(model_id) + lora_config = LoraConfig( target_modules=["q_proj", "k_proj"], init_lora_weights=False @@ -112,14 +113,14 @@ lora_config = LoraConfig( model.add_adapter(lora_config, adapter_name="adapter_1") ``` -Para agregar un nuevo adaptador: +Agregar un nuevo adaptador: ```py # attach new adapter with same config model.add_adapter(lora_config, adapter_name="adapter_2") ``` -Ahora puedes usar [`~peft.PeftModel.set_adapter`] para configurar cuál adaptador para usar: +Ahora puede usar [`~peft.PeftModel.set_adapter`] para configurar cual adaptador usar: ```py # use adapter_1 @@ -133,9 +134,9 @@ output_enabled = model.generate(**inputs) print(tokenizer.decode(output_enabled[0], skip_special_tokens=True)) ``` -## Para activar y desactivar los adaptadores +## Activación y desactivación de los adaptadores -Cuando has agregado un adaptador a un modelo, puedes activar or desactivar el módulo de adaptador. Para activar el módulo de adaptador: +Una vez que haya agregado un adaptador a un modelo, puede activar o desactivar el modulo del adaptador. Para activar el modulo: ```py from transformers import AutoModelForCausalLM, OPTForCausalLM, AutoTokenizer @@ -158,25 +159,24 @@ model.enable_adapters() output = model.generate(**inputs) ``` -Para desactivar el modulo adaptero: +Para desactivar el modulo del adaptador: ```py model.disable_adapters() output = model.generate(**inputs) ``` -## Entrenar un adaptor de PEFT +## Como entrenar un adaptador PEFT -Los adaptadores de PEFT están apoyados por la clase de [`Trainer`] para que puedas entrenar el adaptador para tu caso de uso específico. Sólo requiere agregar unas líneas más de código. Por ejemplo, para entrenar un adaptador de LoRA: +Los adaptadores PEFT son compatibles con la clase [`Trainer`] para que puedas entrenar el adaptador para tu caso de uso específico. Solo requiere agregar unas cuantas lineas mas de codigo. Por ejemplo, para entrenar un adaptador de LoRA: -Si no estás familiarizado con el afinamiento de un modelo con la clase[`Trainer`], mira el tutorial [Fine-tune a pretrained model](training). +Si no esta familiarizado con el afinamiento de un modelo con [`Trainer`], revise el tutorial [Afinamiento de un modelo preentrenado] (training) -1. Define tu configuraciôn de adaptador con el tipo de tarea y hiperparámetros (ves [`~peft.LoraConfig`] para más detalles de lo que - hacen los hiperparámetros). +1. Defina la configuracion de su adaptador con el tipo de tarea y los hiperparametros (consulte [`~peft.LoraConfig`] para obtener mas detalles sobre lo que hacen los hiperparametros). ```py from peft import LoraConfig @@ -190,29 +190,29 @@ peft_config = LoraConfig( ) ``` -2. Agrega el adaptador al modelo. +2. Agregue una daptador al modelo. ```py model.add_adapter(peft_config) ``` -3. ¡Ahora puedes pasar el modelo a [`Trainer`]! +3. ¡Ahora puede pasar el modelo a [`Trainer`]! ```py trainer = Trainer(model=model, ...) trainer.train() ``` -Para archivar tu adaptador entrenado y volver a cargarlo: +Para guardar su adaptador entrenado y volver a cargarlo: ```py model.save_pretrained(save_dir) model = AutoModelForCausalLM.from_pretrained(save_dir) ``` -## Agrega capas entrenables adicionales a un PEFT adaptador +## Agregue capas entrenables adicionales a un adaptador PEFT -Tambien puedes afinar adaptadores entrenables adicionales en encima de un modelo que tiene adaptadores connectados por pasar a `modules_to_save` en tu config de PEFT. Por ejemplo, si tu quieres también afinar el lm_head encima de un modelo con un adaptador de LoRA: +Tambien puede ajustar adaptadores entranbles adicionales sobre un modelo que tiene adaptadores conectados pasando `modules_to_save` en su configuracion PEFT. Por ejemplo, si tambien quieres ajustar el `lm_head` encima de un modelo adaptadpr LoRA: ```py from transformers import AutoModelForCausalLM, OPTForCausalLM, AutoTokenizer @@ -229,6 +229,19 @@ lora_config = LoraConfig( model.add_adapter(lora_config) ``` +## Documentacion API + +[[autodoc]] integrations.PeftAdapterMixin + - load_adapter + - add_adapter + - set_adapter + - disable_adapters + - enable_adapters + - active_adapters + - get_adapter_state_dict + + +