Split (1)

train · 1.16k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

chunk_id stringlengths 44 45	chunk_content stringlengths 21 448	filename stringlengths 36 36
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_9	t": "@HMRCcustomers No this is my first job", "ID": 0, "Label": 2} To make the Label column more readable, replace the Label value with the corresponding label text and store them in a text_label column. You can use the map function to apply this change over the entire dataset in one step: Copied classes = [k.replac...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_10	e("_", " ") for k in dataset["train"].features["Label"].names] dataset = dataset.map( lambda x: {"text_label": [classes[label] for label in x["Label"]]}, batched=True, num_proc=1, ) dataset["train"][0] {"Tweet text": "@HMRCcustomers No this is my first job", "ID": 0, "Label": 2, "text_label": "no complaint"...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_11	} Preprocess dataset Next, you’ll setup a tokenizer; configure the appropriate padding token to use for padding sequences, and determine the maximum length of the tokenized labels: Copied tokenizer = AutoTokenizer.from_pretrained(model_name_or_path) if tokenizer.pad_token_id is None: tokenizer.pad_token_id = ...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_12	tokenizer.eos_token_id target_max_length = max([len(tokenizer(class_label)["input_ids"]) for class_label in classes]) print(target_max_length) 3 Create a preprocess_function to: Tokenize the input text and labels. For each example in a batch, pad the labels with the tokenizers pad_token_id. Concatenate the input text a...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_13	nd labels into the model_inputs. Create a separate attention mask for labels and model_inputs. Loop through each example in the batch again to pad the input ids, labels, and attention mask to the max_length and convert them to PyTorch tensors. Copied def preprocess_function(examples): batch_size = len(examples[t...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_14	ext_column]) inputs = [f"{text_column} : {x} Label : " for x in examples[text_column]] targets = [str(x) for x in examples[label_column]] model_inputs = tokenizer(inputs) labels = tokenizer(targets) for i in range(batch_size): sample_input_ids = model_inputs["input_ids"][i] label_inp...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_15	ut_ids = labels["input_ids"][i] + [tokenizer.pad_token_id] # print(i, sample_input_ids, label_input_ids) model_inputs["input_ids"][i] = sample_input_ids + label_input_ids labels["input_ids"][i] = [-100] * len(sample_input_ids) + label_input_ids model_inputs["attention_mask"][i] = [1] * l...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_16	en(model_inputs["input_ids"][i]) # print(model_inputs) for i in range(batch_size): sample_input_ids = model_inputs["input_ids"][i] label_input_ids = labels["input_ids"][i] model_inputs["input_ids"][i] = [tokenizer.pad_token_id] * ( max_length - len(sample_input_ids) )...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_17	+ sample_input_ids model_inputs["attention_mask"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[ "attention_mask" ][i] labels["input_ids"][i] = [-100] * (max_length - len(sample_input_ids)) + label_input_ids model_inputs["input_ids"][i] = torch.tensor(model_...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_18	inputs["input_ids"][i][:max_length]) model_inputs["attention_mask"][i] = torch.tensor(model_inputs["attention_mask"][i][:max_length]) labels["input_ids"][i] = torch.tensor(labels["input_ids"][i][:max_length]) model_inputs["labels"] = labels["input_ids"] return model_inputs Use the map function t...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_19	o apply the preprocess_function to the entire dataset. You can remove the unprocessed columns since the model won’t need them: Copied processed_datasets = dataset.map( preprocess_function, batched=True, num_proc=1, remove_columns=dataset["train"].column_names, load_from_cache_file=False, desc...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_20	="Running tokenizer on dataset", ) Create a DataLoader from the train and eval datasets. Set pin_memory=True to speed up the data transfer to the GPU during training if the samples in your dataset are on a CPU. Copied train_dataset = processed_datasets["train"] eval_dataset = processed_datasets["test"] train_datal...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_21	oader = DataLoader( train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True ) eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True) Train You’re almost ready to setup your model and start training! Initia...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_22	lize a base model from AutoModelForCausalLM, and pass it and peft_config to the get_peft_model() function to create a PeftModel. You can print the new PeftModel’s trainable parameters to see how much more efficient it is than training the full parameters of the original model! Copied model = AutoModelForCausalLM.fro...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_23	m_pretrained(model_name_or_path) model = get_peft_model(model, peft_config) print(model.print_trainable_parameters()) "trainable params: 8192 \|\| all params: 559222784 \|\| trainable%: 0.0014648902430985358" Setup an optimizer and learning rate scheduler: Copied optimizer = torch.optim.AdamW(model.parameters(), lr=lr) ...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_24	lr_scheduler = get_linear_schedule_with_warmup( optimizer=optimizer, num_warmup_steps=0, num_training_steps=(len(train_dataloader) * num_epochs), ) Move the model to the GPU, then write a training loop to start training! Copied model = model.to(device) for epoch in range(num_epochs): model.train() ...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_25	total_loss = 0 for step, batch in enumerate(tqdm(train_dataloader)): batch = {k: v.to(device) for k, v in batch.items()} outputs = model(**batch) loss = outputs.loss total_loss += loss.detach().float() loss.backward() optimizer.step() lr_scheduler.step() ...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_26	optimizer.zero_grad() model.eval() eval_loss = 0 eval_preds = [] for step, batch in enumerate(tqdm(eval_dataloader)): batch = {k: v.to(device) for k, v in batch.items()} with torch.no_grad(): outputs = model(**batch) loss = outputs.loss eval_loss += los...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_27	s.detach().float() eval_preds.extend( tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True) ) eval_epoch_loss = eval_loss / len(eval_dataloader) eval_ppl = torch.exp(eval_epoch_loss) train_epoch_loss = total_loss / len(train_da...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_28	taloader) train_ppl = torch.exp(train_epoch_loss) print(f"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}") Share model You can store and share your model on the Hub if you’d like. Log in to your Hugging Face account and enter your token when prompted: Copied from huggingface_hub...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_29	import notebook_login notebook_login() Use the push_to_hub function to upload your model to a model repository on the Hub: Copied peft_model_id = "your-name/bloomz-560m_PROMPT_TUNING_CAUSAL_LM" model.push_to_hub("your-name/bloomz-560m_PROMPT_TUNING_CAUSAL_LM", use_auth_token=True) Once the model is uploaded, you’l...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_30	l see the model file size is only 33.5kB! 🤏 Inference Let’s try the model on a sample input for inference. If you look at the repository you uploaded the model to, you’ll see a adapter_config.json file. Load this file into PeftConfig to specify the peft_type and task_type. Then you can load the prompt tuned model w...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_31	ights, and the configuration into from_pretrained() to create the PeftModel: Copied from peft import PeftModel, PeftConfig peft_model_id = "stevhliu/bloomz-560m_PROMPT_TUNING_CAUSAL_LM" config = PeftConfig.from_pretrained(peft_model_id) model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path) m...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_32	odel = PeftModel.from_pretrained(model, peft_model_id) Grab a tweet and tokenize it: Copied inputs = tokenizer( f'{text_column} : {"@nationalgridus I have no water and the bill is current and paid. Can you do something about this?"} Label : ', return_tensors="pt", ) Put the model on a GPU and generate the pr...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_33	edicted label: Copied model.to(device) with torch.no_grad(): inputs = {k: v.to(device) for k, v in inputs.items()} outputs = model.generate( input_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"], max_new_tokens=10, eos_token_id=3 ) print(tokenizer.batch_decode(outputs.detach...	176b966ffabdbae904d70b3c31cdac0c.txt
176b966ffabdbae904d70b3c31cdac0c.txt_chunk_34	().cpu().numpy(), skip_special_tokens=True)) [ "Tweet text : @nationalgridus I have no water and the bill is current and paid. Can you do something about this? Label : complaint" ]	176b966ffabdbae904d70b3c31cdac0c.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_1	LoRA This conceptual guide gives a brief overview of LoRA, a technique that accelerates the fine-tuning of large models while consuming less memory. To make fine-tuning more efficient, LoRA’s approach is to represent the weight updates with two smaller matrices (called update matrices) through low-rank decompositio...	5b417ea7788f707968c7b3e47dee06e5.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_2	n. These new matrices can be trained to adapt to the new data while keeping the overall number of changes low. The original weight matrix remains frozen and doesn’t receive any further adjustments. To produce the final results, both the original and the adapted weights are combined. This approach has a number of advant...	5b417ea7788f707968c7b3e47dee06e5.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_3	ages: LoRA makes fine-tuning more efficient by drastically reducing the number of trainable parameters. The original pre-trained weights are kept frozen, which means you can have multiple lightweight and portable LoRA models for various downstream tasks built on top of them. LoRA is orthogonal to many other parameter-...	5b417ea7788f707968c7b3e47dee06e5.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_4	efficient methods and can be combined with many of them. Performance of models fine-tuned using LoRA is comparable to the performance of fully fine-tuned models. LoRA does not add any inference latency because adapter weights can be merged with the base model. In principle, LoRA can be applied to any subset of weight m...	5b417ea7788f707968c7b3e47dee06e5.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_5	atrices in a neural network to reduce the number of trainable parameters. However, for simplicity and further parameter efficiency, in Transformer models LoRA is typically applied to attention blocks only. The resulting number of trainable parameters in a LoRA model depends on the size of the low-rank update matrices, ...	5b417ea7788f707968c7b3e47dee06e5.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_6	which is determined mainly by the rank r and the shape of the original weight matrix. Merge LoRA weights into the base model While LoRA is significantly smaller and faster to train, you may encounter latency issues during inference due to separately loading the base model and the LoRA model. To eliminate latency, us...	5b417ea7788f707968c7b3e47dee06e5.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_7	e the merge_and_unload() function to merge the adapter weights with the base model which allows you to effectively use the newly merged model as a standalone model. This works because during training, the smaller weight matrices (A and B in the diagram above) are separate. But once training is complete, the weights ca...	5b417ea7788f707968c7b3e47dee06e5.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_8	n actually be merged into a new weight matrix that is identical. Utils for LoRA Use merge_adapter() to merge the LoRa layers into the base model while retaining the PeftModel. This will help in later unmerging, deleting, loading different adapters and so on. Use unmerge_adapter() to unmerge the LoRa layers from the ...	5b417ea7788f707968c7b3e47dee06e5.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_9	base model while retaining the PeftModel. This will help in later merging, deleting, loading different adapters and so on. Use unload() to get back the base model without the merging of the active lora modules. This will help when you want to get back the pretrained base model in some applications when you want to rese...	5b417ea7788f707968c7b3e47dee06e5.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_10	t the model to its original state. For example, in Stable Diffusion WebUi, when the user wants to infer with base model post trying out LoRAs. Use delete_adapter() to delete an existing adapter. Use add_weighted_adapter() to combine multiple LoRAs into a new adapter based on the user provided weighing scheme. Common L...	5b417ea7788f707968c7b3e47dee06e5.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_11	oRA parameters in PEFT As with other methods supported by PEFT, to fine-tune a model using LoRA, you need to: Instantiate a base model. Create a configuration (LoraConfig) where you define LoRA-specific parameters. Wrap the base model with get_peft_model() to get a trainable PeftModel. Train the PeftModel as you norm...	5b417ea7788f707968c7b3e47dee06e5.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_12	ally would train the base model. LoraConfig allows you to control how LoRA is applied to the base model through the following parameters: r: the rank of the update matrices, expressed in int. Lower rank results in smaller update matrices with fewer trainable parameters. target_modules: The modules (for example, attent...	5b417ea7788f707968c7b3e47dee06e5.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_13	ion blocks) to apply the LoRA update matrices. alpha: LoRA scaling factor. bias: Specifies if the bias parameters should be trained. Can be 'none', 'all' or 'lora_only'. modules_to_save: List of modules apart from LoRA layers to be set as trainable and saved in the final checkpoint. These typically include model’s cust...	5b417ea7788f707968c7b3e47dee06e5.txt
5b417ea7788f707968c7b3e47dee06e5.txt_chunk_14	om head that is randomly initialized for the fine-tuning task. layers_to_transform: List of layers to be transformed by LoRA. If not specified, all layers in target_modules are transformed. layers_pattern: Pattern to match layer names in target_modules, if layers_to_transform is specified. By default PeftModel will loo...	5b417ea7788f707968c7b3e47dee06e5.txt