Datasets:

smangrul
/

peft_docs

chunk_id stringlengths 44 45	chunk_content stringlengths 21 448	filename stringlengths 36 36
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_1	Semantic segmentation using LoRA This guide demonstrates how to use LoRA, a low-rank approximation technique, to finetune a SegFormer model variant for semantic segmentation. By using LoRA from 🤗 PEFT, we can reduce the number of trainable parameters in the SegFormer model to only 14% of the original trainable param...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_2	ters. LoRA achieves this reduction by adding low-rank “update matrices” to specific blocks of the model, such as the attention blocks. During fine-tuning, only these matrices are trained, while the original model parameters are left unchanged. At inference time, the update matrices are merged with the original model pa...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_3	rameters to produce the final classification result. For more information on LoRA, please refer to the original LoRA paper. Install dependencies Install the libraries required for model training: Copied !pip install transformers accelerate evaluate datasets peft -q Authenticate to share your model To share the...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_4	finetuned model with the community at the end of the training, authenticate using your 🤗 token. You can obtain your token from your account settings. Copied from huggingface_hub import notebook_login notebook_login() Load a dataset To ensure that this example runs within a reasonable time frame, here we are li...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_5	iting the number of instances from the training set of the SceneParse150 dataset to 150. Copied from datasets import load_dataset ds = load_dataset("scene_parse_150", split="train[:150]") Next, split the dataset into train and test sets. Copied ds = ds.train_test_split(test_size=0.1) train_ds = ds["train"] tes...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_6	t_ds = ds["test"] Prepare label maps Create a dictionary that maps a label id to a label class, which will be useful when setting up the model later: label2id: maps the semantic classes of the dataset to integer ids. id2label: maps integer ids back to the semantic classes. Copied import json from huggingface_hub...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_7	import cached_download, hf_hub_url repo_id = "huggingface/label-files" filename = "ade20k-hf-doc-builder.json" id2label = json.load(open(cached_download(hf_hub_url(repo_id, filename, repo_type="dataset")), "r")) id2label = {int(k): v for k, v in id2label.items()} label2id = {v: k for k, v in id2label.items()} num_lab...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_8	els = len(id2label) Prepare datasets for training and evaluation Next, load the SegFormer image processor to prepare the images and annotations for the model. This dataset uses the zero-index as the background class, so make sure to set reduce_labels=True to subtract one from all labels since the background class is...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_9	not among the 150 classes. Copied from transformers import AutoImageProcessor checkpoint = "nvidia/mit-b0" image_processor = AutoImageProcessor.from_pretrained(checkpoint, reduce_labels=True) Add a function to apply data augmentation to the images, so that the model is more robust against overfitting. Here we use...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_10	the ColorJitter function from torchvision to randomly change the color properties of an image. Copied from torchvision.transforms import ColorJitter jitter = ColorJitter(brightness=0.25, contrast=0.25, saturation=0.25, hue=0.1) Add a function to handle grayscale images and ensure that each input image has three co...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_11	lor channels, regardless of whether it was originally grayscale or RGB. The function converts RGB images to array as is, and for grayscale images that have only one color channel, the function replicates the same channel three times using np.tile() before converting the image into an array. Copied import numpy as np...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_12	def handle_grayscale_image(image): np_image = np.array(image) if np_image.ndim == 2: tiled_image = np.tile(np.expand_dims(np_image, -1), 3) return Image.fromarray(tiled_image) else: return Image.fromarray(np_image) Finally, combine everything in two functions that you’ll use to tr...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_13	ansform training and validation data. The two functions are similar except data augmentation is applied only to the training data. Copied from PIL import Image def train_transforms(example_batch): images = [jitter(handle_grayscale_image(x)) for x in example_batch["image"]] labels = [x for x in example_ba...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_14	tch["annotation"]] inputs = image_processor(images, labels) return inputs def val_transforms(example_batch): images = [handle_grayscale_image(x) for x in example_batch["image"]] labels = [x for x in example_batch["annotation"]] inputs = image_processor(images, labels) return inputs To apply th...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_15	e preprocessing functions over the entire dataset, use the 🤗 Datasets set_transform function: Copied train_ds.set_transform(train_transforms) test_ds.set_transform(val_transforms) Create evaluation function Including a metric during training is helpful for evaluating your model’s performance. You can load an eva...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_16	uation method with the 🤗 Evaluate library. For this task, use the mean Intersection over Union (IoU) metric (see the 🤗 Evaluate quick tour to learn more about how to load and compute a metric): Copied import torch from torch import nn import evaluate metric = evaluate.load("mean_iou") def compute_metrics(eval_p...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_17	d): with torch.no_grad(): logits, labels = eval_pred logits_tensor = torch.from_numpy(logits) logits_tensor = nn.functional.interpolate( logits_tensor, size=labels.shape[-2:], mode="bilinear", align_corners=False, ).argmax(dim=1) ...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_18	pred_labels = logits_tensor.detach().cpu().numpy() # currently using _compute instead of compute # see this issue for more info: https://github.com/huggingface/evaluate/pull/328#issuecomment-1286866576 metrics = metric._compute( predictions=pred_labels, references=labe...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_19	ls, num_labels=len(id2label), ignore_index=0, reduce_labels=image_processor.reduce_labels, ) per_category_accuracy = metrics.pop("per_category_accuracy").tolist() per_category_iou = metrics.pop("per_category_iou").tolist() metrics.update({f"accuracy_...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_20	{id2label[i]}": v for i, v in enumerate(per_category_accuracy)}) metrics.update({f"iou_{id2label[i]}": v for i, v in enumerate(per_category_iou)}) return metrics Load a base model Before loading a base model, let’s define a helper function to check the total number of parameters a model has, as wel...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_21	l as how many of them are trainable. Copied def print_trainable_parameters(model): """ Prints the number of trainable parameters in the model. """ trainable_params = 0 all_param = 0 for _, param in model.named_parameters(): all_param += param.numel() if param.requires_grad: ...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_22	trainable_params += param.numel() print( f"trainable params: {trainable_params} \|\| all params: {all_param} \|\| trainable%: {100 * trainable_params / all_param:.2f}" ) Choose a base model checkpoint. For this example, we use the SegFormer B0 variant. In addition to the checkpoint, pass the label...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_23	2id and id2label dictionaries to let the AutoModelForSemanticSegmentation class know that we’re interested in a custom base model where the decoder head should be randomly initialized using the classes from the custom dataset. Copied from transformers import AutoModelForSemanticSegmentation, TrainingArguments, Train...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_24	er model = AutoModelForSemanticSegmentation.from_pretrained( checkpoint, id2label=id2label, label2id=label2id, ignore_mismatched_sizes=True ) print_trainable_parameters(model) At this point you can check with the print_trainable_parameters helper function that all 100% parameters in the base model (aka model) are ...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_25	trainable. Wrap the base model as a PeftModel for LoRA training To leverage the LoRa method, you need to wrap the base model as a PeftModel. This involves two steps: Defining LoRa configuration with LoraConfig Wrapping the original model with get_peft_model() using the config defined in the step above. Copied fr...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_26	om peft import LoraConfig, get_peft_model config = LoraConfig( r=32, lora_alpha=32, target_modules=["query", "value"], lora_dropout=0.1, bias="lora_only", modules_to_save=["decode_head"], ) lora_model = get_peft_model(model, config) print_trainable_parameters(lora_model) Let’s review the LoraCo...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_27	nfig. To enable LoRA technique, we must define the target modules within LoraConfig so that PeftModel can update the necessary matrices. Specifically, we want to target the query and value matrices in the attention blocks of the base model. These matrices are identified by their respective names, “query” and “value”. T...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_28	herefore, we should specify these names in the target_modules argument of LoraConfig. After we wrap our base model model with PeftModel along with the config, we get a new model where only the LoRA parameters are trainable (so-called “update matrices”) while the pre-trained parameters are kept frozen. These include the...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_29	parameters of the randomly initialized classifier parameters too. This is NOT we want when fine-tuning the base model on our custom dataset. To ensure that the classifier parameters are also trained, we specify modules_to_save. This also ensures that these modules are serialized alongside the LoRA trainable parameters...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_30	when using utilities like save_pretrained() and push_to_hub(). In addition to specifying the target_modules within LoraConfig, we also need to specify the modules_to_save. When we wrap our base model with PeftModel and pass the configuration, we obtain a new model in which only the LoRA parameters are trainable, while...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_31	the pre-trained parameters and the randomly initialized classifier parameters are kept frozen. However, we do want to train the classifier parameters. By specifying the modules_to_save argument, we ensure that the classifier parameters are also trainable, and they will be serialized alongside the LoRA trainable parame...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_32	ters when we use utility functions like save_pretrained() and push_to_hub(). Let’s review the rest of the parameters: r: The dimension used by the LoRA update matrices. alpha: Scaling factor. bias: Specifies if the bias parameters should be trained. None denotes none of the bias parameters will be trained. When all is ...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_33	configured, and the base model is wrapped, the print_trainable_parameters helper function lets us explore the number of trainable parameters. Since we’re interested in performing parameter-efficient fine-tuning, we should expect to see a lower number of trainable parameters from the lora_model in comparison to the orig...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_34	inal model which is indeed the case here. You can also manually verify what modules are trainable in the lora_model. Copied for name, param in lora_model.named_parameters(): if param.requires_grad: print(name, param.shape) This confirms that only the LoRA parameters appended to the attention blocks and t...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_35	he decode_head parameters are trainable. Train the model Start by defining your training hyperparameters in TrainingArguments. You can change the values of most parameters however you prefer. Make sure to set remove_unused_columns=False, otherwise the image column will be dropped, and it’s required here. The only ot...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_36	her required parameter is output_dir which specifies where to save your model. At the end of each epoch, the Trainer will evaluate the IoU metric and save the training checkpoint. Note that this example is meant to walk you through the workflow when using PEFT for semantic segmentation. We didn’t perform extensive hype...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_37	rparameter tuning to achieve optimal results. Copied model_name = checkpoint.split("/")[-1] training_args = TrainingArguments( output_dir=f"{model_name}-scene-parse-150-lora", learning_rate=5e-4, num_train_epochs=50, per_device_train_batch_size=4, per_device_eval_batch_size=2, save_total_lim...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_38	it=3, evaluation_strategy="epoch", save_strategy="epoch", logging_steps=5, remove_unused_columns=False, push_to_hub=True, label_names=["labels"], ) Pass the training arguments to Trainer along with the model, dataset, and compute_metrics function. Call train() to finetune your model. Copied t...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_39	rainer = Trainer( model=lora_model, args=training_args, train_dataset=train_ds, eval_dataset=test_ds, compute_metrics=compute_metrics, ) trainer.train() Save the model and run inference Use the save_pretrained() method of the lora_model to save the LoRA-only parameters locally. Alternatively, u...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt
67f2c0a9b6ab4f4cb1294820fa4c0028.txt_chunk_40	se the push_to_hub() method to upload these parameters directly to the Hugging Face Hub (as shown in the Image classification using LoRA task guide). Copied model_id = "segformer-scene-parse-150-lora" lora_model.save_pretrained(model_id) We can see that the LoRA-only parameters are just 2.2 MB in size! This greatly ...	67f2c0a9b6ab4f4cb1294820fa4c0028.txt