ee5f18566efe5c4e3eedda4442c7cf14c467b381b622b24f9a539f4ef1b1d1c9

peft_md_files/tutorial/peft_integrations.md

@@ -1,152 +0,0 @@
-<!--Copyright 2023 The HuggingFace Team. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
-an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-specific language governing permissions and limitations under the License.
-
-⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
-rendered properly in your Markdown viewer.
-
--->
-
-# PEFT integrations
-
-PEFT's practical benefits extends to other Hugging Face libraries like [Diffusers](https://hf.co/docs/diffusers) and [Transformers](https://hf.co/docs/transformers). One of the main benefits of PEFT is that an adapter file generated by a PEFT method is a lot smaller than the original model, which makes it super easy to manage and use multiple adapters. You can use one pretrained base model for multiple tasks by simply loading a new adapter finetuned for the task you're solving. Or you can combine multiple adapters with a text-to-image diffusion model to create new effects.
-
-This tutorial will show you how PEFT can help you manage adapters in Diffusers and Transformers.
-
-## Diffusers
-
-Diffusers is a generative AI library for creating images and videos from text or images with diffusion models. LoRA is an especially popular training method for diffusion models because you can very quickly train and share diffusion models to generate images in new styles. To make it easier to use and try multiple LoRA models, Diffusers uses the PEFT library to help manage different adapters for inference.
-
-For example, load a base model and then load the [artificialguybr/3DRedmond-V1](https://huggingface.co/artificialguybr/3DRedmond-V1) adapter for inference with the [`load_lora_weights`](https://huggingface.co/docs/diffusers/v0.24.0/en/api/loaders/lora#diffusers.loaders.LoraLoaderMixin.load_lora_weights) method. The `adapter_name` argument in the loading method is enabled by PEFT and allows you to set a name for the adapter so it is easier to reference.
-
-```py
-import torch
-from diffusers import DiffusionPipeline
-
-pipeline = DiffusionPipeline.from_pretrained(
-    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
-).to("cuda")
-pipeline.load_lora_weights(
-    "peft-internal-testing/artificialguybr__3DRedmond-V1", 
-    weight_name="3DRedmond-3DRenderStyle-3DRenderAF.safetensors", 
-    adapter_name="3d"
-)
-image = pipeline("sushi rolls shaped like kawaii cat faces").images[0]
-image
-```
-
-<div class="flex justify-center">
-    <img src="https://huggingface.co/datasets/ybelkada/documentation-images/resolve/main/test-lora-diffusers.png"/>
-</div>
-
-Now let's try another cool LoRA model, [ostris/super-cereal-sdxl-lora](https://huggingface.co/ostris/super-cereal-sdxl-lora). All you need to do is load and name this new adapter with `adapter_name`, and use the [`set_adapters`](https://huggingface.co/docs/diffusers/api/loaders/unet#diffusers.loaders.UNet2DConditionLoadersMixin.set_adapters) method to set it as the currently active adapter.
-
-```py
-pipeline.load_lora_weights(
-    "ostris/super-cereal-sdxl-lora", 
-    weight_name="cereal_box_sdxl_v1.safetensors", 
-    adapter_name="cereal"
-)
-pipeline.set_adapters("cereal")
-image = pipeline("sushi rolls shaped like kawaii cat faces").images[0]
-image
-```
-
-<div class="flex justify-center">
-    <img src="https://huggingface.co/datasets/ybelkada/documentation-images/resolve/main/test-lora-diffusers-2.png"/>
-</div>
-
-Finally, you can call the [`disable_lora`](https://huggingface.co/docs/diffusers/api/loaders/unet#diffusers.loaders.UNet2DConditionLoadersMixin.disable_lora) method to restore the base model.
-
-```py
-pipeline.disable_lora()
-```
-
-Learn more about how PEFT supports Diffusers in the [Inference with PEFT](https://huggingface.co/docs/diffusers/tutorials/using_peft_for_inference) tutorial.
-
-## Transformers
-
-🤗 [Transformers](https://hf.co/docs/transformers) is a collection of pretrained models for all types of tasks in all modalities. You can load these models for training or inference. Many of the models are large language models (LLMs), so it makes sense to integrate PEFT with Transformers to manage and train adapters.
-
-Load a base pretrained model to train.
-
-```py
-from transformers import AutoModelForCausalLM
-
-model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
-```
-
-Next, add an adapter configuration to specify how to adapt the model parameters. Call the [`~PeftModel.add_adapter`] method to add the configuration to the base model.
-
-```py
-from peft import LoraConfig
-
-peft_config = LoraConfig(
-    lora_alpha=16,
-    lora_dropout=0.1,
-    r=64,
-    bias="none",
-    task_type="CAUSAL_LM"
-)
-model.add_adapter(peft_config)
-```
-
-Now you can train the model with Transformer's [`~transformers.Trainer`] class or whichever training framework you prefer.
-
-To use the newly trained model for inference, the [`~transformers.AutoModel`] class uses PEFT on the backend to load the adapter weights and configuration file into a base pretrained model.
-
-```py
-from transformers import AutoModelForCausalLM
-
-model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-350m-lora")
-```
-
-Alternatively, you can use transformers [Pipelines](https://huggingface.co/docs/transformers/en/main_classes/pipelines) to load the model for conveniently running inference:
-
-```py
-from transformers import pipeline
-
-model = pipeline("text-generation", "peft-internal-testing/opt-350m-lora")
-print(model("Hello World"))
-```
-
-If you're interested in comparing or using more than one adapter, you can call the [`~PeftModel.add_adapter`] method to add the adapter configuration to the base model. The only requirement is the adapter type must be the same (you can't mix a LoRA and LoHa adapter).
-
-```py
-from transformers import AutoModelForCausalLM
-from peft import LoraConfig
-
-model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
-model.add_adapter(lora_config_1, adapter_name="adapter_1")
-```
-
-Call [`~PeftModel.add_adapter`] again to attach a new adapter to the base model.
-
-```py
-model.add_adapter(lora_config_2, adapter_name="adapter_2")
-```
-
-Then you can use [`~PeftModel.set_adapter`] to set the currently active adapter.
-
-```py
-model.set_adapter("adapter_1")
-output = model.generate(**inputs)
-print(tokenizer.decode(output_disabled[0], skip_special_tokens=True))
-```
-
-To disable the adapter, call the [disable_adapters](https://github.com/huggingface/transformers/blob/4e3490f79b40248c53ee54365a9662611e880892/src/transformers/integrations/peft.py#L313) method.
-
-```py
-model.disable_adapters()
-```
-
-The [enable_adapters](https://github.com/huggingface/transformers/blob/4e3490f79b40248c53ee54365a9662611e880892/src/transformers/integrations/peft.py#L336) can be used to enable the adapters again.
-
-If you're curious, check out the [Load and train adapters with PEFT](https://huggingface.co/docs/transformers/main/peft) tutorial to learn more.

peft_md_files/tutorial/peft_model_config.md

@@ -1,182 +0,0 @@
-<!--Copyright 2023 The HuggingFace Team. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
-an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-specific language governing permissions and limitations under the License.
-
-⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
-rendered properly in your Markdown viewer.
-
--->
-
-# PEFT configurations and models
-
-The sheer size of today's large pretrained models - which commonly have billions of parameters - present a significant training challenge because they require more storage space and more computational power to crunch all those calculations. You'll need access to powerful GPUs or TPUs to train these large pretrained models which is expensive, not widely accessible to everyone, not environmentally friendly, and not very practical. PEFT methods address many of these challenges. There are several types of PEFT methods (soft prompting, matrix decomposition, adapters), but they all focus on the same thing, reduce the number of trainable parameters. This makes it more accessible to train and store large models on consumer hardware.
-
-The PEFT library is designed to help you quickly train large models on free or low-cost GPUs, and in this tutorial, you'll learn how to setup a configuration to apply a PEFT method to a pretrained base model for training. Once the PEFT configuration is setup, you can use any training framework you like (Transformer's [`~transformers.Trainer`] class, [Accelerate](https://hf.co/docs/accelerate), a custom PyTorch training loop).
-
-## PEFT configurations
-
-<Tip>
-
-Learn more about the parameters you can configure for each PEFT method in their respective API reference page.
-
-</Tip>
-
-A configuration stores important parameters that specify how a particular PEFT method should be applied.
-
-For example, take a look at the following [`LoraConfig`](https://huggingface.co/ybelkada/opt-350m-lora/blob/main/adapter_config.json) for applying LoRA and [`PromptEncoderConfig`](https://huggingface.co/smangrul/roberta-large-peft-p-tuning/blob/main/adapter_config.json) for applying p-tuning (these configuration files are already JSON-serialized). Whenever you load a PEFT adapter, it is a good idea to check whether it has an associated adapter_config.json file which is required.
-
-<hfoptions id="config">
-<hfoption id="LoraConfig">
-
-```json
-{
-  "base_model_name_or_path": "facebook/opt-350m", #base model to apply LoRA to
-  "bias": "none",
-  "fan_in_fan_out": false,
-  "inference_mode": true,
-  "init_lora_weights": true,
-  "layers_pattern": null,
-  "layers_to_transform": null,
-  "lora_alpha": 32,
-  "lora_dropout": 0.05,
-  "modules_to_save": null,
-  "peft_type": "LORA", #PEFT method type
-  "r": 16,
-  "revision": null,
-  "target_modules": [
-    "q_proj", #model modules to apply LoRA to (query and value projection layers)
-    "v_proj"
-  ],
-  "task_type": "CAUSAL_LM" #type of task to train model on
-}
-```
-
-You can create your own configuration for training by initializing a [`LoraConfig`].
-
-```py
-from peft import LoraConfig, TaskType
-
-lora_config = LoraConfig(
-    r=16,
-    target_modules=["q_proj", "v_proj"],
-    task_type=TaskType.CAUSAL_LM,
-    lora_alpha=32,
-    lora_dropout=0.05
-)
-```
-
-</hfoption>
-<hfoption id="PromptEncoderConfig">
-
-```json
-{
-  "base_model_name_or_path": "roberta-large", #base model to apply p-tuning to
-  "encoder_dropout": 0.0,
-  "encoder_hidden_size": 128,
-  "encoder_num_layers": 2,
-  "encoder_reparameterization_type": "MLP",
-  "inference_mode": true,
-  "num_attention_heads": 16,
-  "num_layers": 24,
-  "num_transformer_submodules": 1,
-  "num_virtual_tokens": 20,
-  "peft_type": "P_TUNING", #PEFT method type
-  "task_type": "SEQ_CLS", #type of task to train model on
-  "token_dim": 1024
-}
-```
-
-You can create your own configuration for training by initializing a [`PromptEncoderConfig`].
-
-```py
-from peft import PromptEncoderConfig, TaskType
-
-p_tuning_config = PromptEncoderConfig(
-    encoder_reparameterization_type="MLP",
-    encoder_hidden_size=128,
-    num_attention_heads=16,
-    num_layers=24,
-    num_transformer_submodules=1,
-    num_virtual_tokens=20,
-    token_dim=1024,
-    task_type=TaskType.SEQ_CLS
-)
-```
-
-</hfoption>
-</hfoptions>
-
-## PEFT models
-
-With a PEFT configuration in hand, you can now apply it to any pretrained model to create a [`PeftModel`]. Choose from any of the state-of-the-art models from the [Transformers](https://hf.co/docs/transformers) library, a custom model, and even new and unsupported transformer architectures.
-
-For this tutorial, load a base [facebook/opt-350m](https://huggingface.co/facebook/opt-350m) model to finetune.
-
-```py
-from transformers import AutoModelForCausalLM
-
-model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
-```
-
-Use the [`get_peft_model`] function to create a [`PeftModel`] from the base facebook/opt-350m model and the `lora_config` you created earlier.
-
-```py
-from peft import get_peft_model
-
-lora_model = get_peft_model(model, lora_config)
-lora_model.print_trainable_parameters()
-"trainable params: 1,572,864 || all params: 332,769,280 || trainable%: 0.472659014678278"
-```
-
-Now you can train the [`PeftModel`] with your preferred training framework! After training, you can save your model locally with [`~PeftModel.save_pretrained`] or upload it to the Hub with the [`~transformers.PreTrainedModel.push_to_hub`] method.
-
-```py
-# save locally
-lora_model.save_pretrained("your-name/opt-350m-lora")
-
-# push to Hub
-lora_model.push_to_hub("your-name/opt-350m-lora")
-```
-
-To load a [`PeftModel`] for inference, you'll need to provide the [`PeftConfig`] used to create it and the base model it was trained from.
-
-```py
-from peft import PeftModel, PeftConfig
-
-config = PeftConfig.from_pretrained("ybelkada/opt-350m-lora")
-model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)
-lora_model = PeftModel.from_pretrained(model, "ybelkada/opt-350m-lora")
-```
-
-<Tip>
-
-By default, the [`PeftModel`] is set for inference, but if you'd like to train the adapter some more you can set `is_trainable=True`.
-
-```py
-lora_model = PeftModel.from_pretrained(model, "ybelkada/opt-350m-lora", is_trainable=True)
-```
-
-</Tip>
-
-The [`PeftModel.from_pretrained`] method is the most flexible way to load a [`PeftModel`] because it doesn't matter what model framework was used (Transformers, timm, a generic PyTorch model). Other classes, like [`AutoPeftModel`], are just a convenient wrapper around the base [`PeftModel`], and makes it easier to load PEFT models directly from the Hub or locally where the PEFT weights are stored.
-
-```py
-from peft import AutoPeftModelForCausalLM
-
-lora_model = AutoPeftModelForCausalLM.from_pretrained("ybelkada/opt-350m-lora")
-```
-
-Take a look at the [AutoPeftModel](package_reference/auto_class) API reference to learn more about the [`AutoPeftModel`] classes.
-
-## Next steps
-
-With the appropriate [`PeftConfig`], you can apply it to any pretrained model to create a [`PeftModel`] and train large powerful models faster on freely available GPUs! To learn more about PEFT configurations and models, the following guide may be helpful:
-
-* Learn how to configure a PEFT method for models that aren't from Transformers in the [Working with custom models](../developer_guides/custom_models) guide.