Tremendous Tuning LLAMAv2 with QLora on Google Colab for Free

Under is an instruction that describes a activity, paired with an enter that gives additional context. Write a response that appropriately completes the request.

### Instruction:
{instruction}

### Enter:
{enter}

### Response:
{response}

import pandas as pd

df = pd.read_csv('snli_1.0_train_matched.csv')
df['gold_label'].value_counts().plot(variety='barh')

df[df['gold_label'] == 'contradiction'].pattern(10)[['sentence1', 'sentence2']]

def convert_to_format(row):
    sentence1 = row['sentence1']
    sentence2 = row['sentence2']ccccc
    immediate = """Under is an instruction that describes a activity paired with enter that gives additional context. Write a response that appropriately completes the request."""
    instruction = """Given the next sentence, your job is to generate the negation for it within the json format"""
    enter = str(sentence1)
    response = f"""```json
{{'orignal_sentence': '{sentence1}', 'generated_negation': '{sentence2}'}}
```
"""
    if len(enter.strip()) == 0:  #  immediate + 2 new strains + ###instruction + new line + enter + new line + ###response
        textual content = immediate + "nn### Instruction:n" + instruction + "n### Response:n" + response
    else:
        textual content = immediate + "nn### Instruction:n" + instruction + "n### Enter:n" + enter + "n" + "n### Response:n" + response
    
    # we'd like 4 columns for auto prepare, instruction, enter, output, textual content
    return pd.Sequence([instruction, input, response, text])

new_df = df[df['gold_label'] == 'contradiction'][['sentence1', 'sentence2']].apply(convert_to_format, axis=1)
new_df.columns = ['instruction', 'input', 'output', 'text']

new_df.to_csv('snli_instruct.csv', index=False)

"Under is an instruction that describes a activity paired with enter that gives additional context. Write a response that appropriately completes the request.

### Instruction:
Given the next sentence, your job is to generate the negation for it within the json format
### Enter:
A pair taking part in with a little bit boy on the seashore.

### Response:
```json
{'orignal_sentence': 'A pair taking part in with a little bit boy on the seashore.', 'generated_negation': 'A pair watch a little bit lady play by herself on the seashore.'}
```

!pip set up -q speed up==0.21.0 peft==0.4.0 bitsandbytes==0.40.2 transformers==4.31.0 trl==0.4.7

import os
import torch
from datasets import load_dataset
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    HfArgumentParser,
    TrainingArguments,
    pipeline,
    logging,
)
from peft import LoraConfig, PeftModel
from trl import SFTTrainer

from google.colab import drive
import pandas as pd

drive.mount('/content material/drive')

df = pd.read_csv('/content material/drive/MyDrive/snli_instruct.csv')

from datasets import Dataset

dataset = Dataset.from_pandas(df)

# The mannequin that you just wish to prepare from the Hugging Face hub
model_name = "abhishek/llama-2-7b-hf-small-shards"

# Tremendous-tuned mannequin identify
new_model = "llama-2-contradictor"

################################################################################
# QLoRA parameters
################################################################################

# LoRA consideration dimension
lora_r = 64

# Alpha parameter for LoRA scaling
lora_alpha = 16

# Dropout chance for LoRA layers
lora_dropout = 0.1

################################################################################
# bitsandbytes parameters
################################################################################

# Activate 4-bit precision base mannequin loading
use_4bit = True

# Compute dtype for 4-bit base fashions
bnb_4bit_compute_dtype = "float16"

# Quantization kind (fp4 or nf4)
bnb_4bit_quant_type = "nf4"

# Activate nested quantization for 4-bit base fashions (double quantization)
use_nested_quant = False

################################################################################
# TrainingArguments parameters
################################################################################

# Output listing the place the mannequin predictions and checkpoints shall be saved
output_dir = "./outcomes"

# Variety of coaching epochs
num_train_epochs = 1

# Allow fp16/bf16 coaching (set bf16 to True with an A100)
fp16 = False
bf16 = False

# Batch dimension per GPU for coaching
per_device_train_batch_size = 4

# Batch dimension per GPU for analysis
per_device_eval_batch_size = 4

# Variety of replace steps to build up the gradients for
gradient_accumulation_steps = 1

# Allow gradient checkpointing
gradient_checkpointing = True

# Most gradient regular (gradient clipping)
max_grad_norm = 0.3

# Preliminary studying charge (AdamW optimizer)
learning_rate = 1e-5

# Weight decay to use to all layers besides bias/LayerNorm weights
weight_decay = 0.001

# Optimizer to make use of
optim = "paged_adamw_32bit"

# Studying charge schedule
lr_scheduler_type = "cosine"

# Variety of coaching steps (overrides num_train_epochs)
max_steps = -1

# Ratio of steps for a linear warmup (from 0 to studying charge)
warmup_ratio = 0.03

# Group sequences into batches with identical size
# Saves reminiscence and quickens coaching significantly
group_by_length = True

# Save checkpoint each X updates steps
save_steps = 0

# Log each X updates steps
logging_steps = 100

################################################################################
# SFT parameters
################################################################################

# Most sequence size to make use of
max_seq_length = None

# Pack a number of brief examples in the identical enter sequence to extend effectivity
packing = False

# Load your entire mannequin on the GPU 0
device_map = {"": 0}

compute_dtype = getattr(torch, bnb_4bit_compute_dtype)

bnb_config = BitsAndBytesConfig(
    load_in_4bit=use_4bit,
    bnb_4bit_quant_type=bnb_4bit_quant_type,
    bnb_4bit_compute_dtype=compute_dtype,
    bnb_4bit_use_double_quant=use_nested_quant,
)

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "proper"

mannequin = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map=device_map
)
mannequin.config.use_cache = False
mannequin.config.pretraining_tp = 1

# Load LoRA configuration
peft_config = LoraConfig(
    lora_alpha=lora_alpha,
    lora_dropout=lora_dropout,
    r=lora_r,
    bias="none",
    task_type="CAUSAL_LM",
)

# Set coaching parameters
training_arguments = TrainingArguments(
    output_dir=output_dir,
    num_train_epochs=num_train_epochs,
    per_device_train_batch_size=per_device_train_batch_size,
    gradient_accumulation_steps=gradient_accumulation_steps,
    optim=optim,
    save_steps=save_steps,
    logging_steps=logging_steps,
    learning_rate=learning_rate,
    weight_decay=weight_decay,
    fp16=fp16,
    bf16=bf16,
    max_grad_norm=max_grad_norm,
    max_steps=max_steps,
    warmup_ratio=warmup_ratio,
    group_by_length=group_by_length,
    lr_scheduler_type=lr_scheduler_type,
    report_to="tensorboard"
)

# Set supervised fine-tuning parameters
coach = SFTTrainer(
    mannequin=mannequin,
    train_dataset=dataset,
    peft_config=peft_config,
    dataset_text_field="textual content",  # that is the textual content column in dataset 
    max_seq_length=max_seq_length,
    tokenizer=tokenizer,
    args=training_arguments,
    packing=packing,
)

# Prepare mannequin
coach.prepare()

# Save skilled mannequin
coach.mannequin.save_pretrained(new_model)

!zip -r llama-contradictor.zip outcomes llama-contradictor
!mv llama-contradictor.zip /content material/drive/MyDrive

!unzip /content material/drive/MyDrive/llama-contradictor.zip -d .

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "proper"

base_model = AutoModelForCausalLM.from_pretrained(
    "abhishek/llama-2-7b-hf-small-shards",
    low_cpu_mem_usage=True,
    return_dict=True,
    torch_dtype=torch.float16,
    device_map={"": 0},
)

mannequin = PeftModel.from_pretrained(base_model, '/content material/llama-contradictor')
mannequin = mannequin.merge_and_unload()
pipe = pipeline(activity="text-generation", mannequin=mannequin, tokenizer=tokenizer, max_length=200)

prompt_template = """### Instruction:
Given the next sentence, your job is to generate the negation for it within the json format
### Enter:
{}

### Response:
"""

sentence = "The climate forecast predicts a sunny day with a excessive temperature round 30 levels Celsius, excellent for a day on the seashore with family and friends."

input_sentence = prompt_template.format(sentence.strip())

end result = pipe(input_sentence)
print(end result)

### Instruction:
Given the next sentence, your job is to generate the negation for it within the json format
### Enter:
The climate forecast predicts a sunny day with a excessive temperature round 30 levels Celsius, excellent for a day on the seashore with family and friends.

### Response:
```json
{
  "sentence": "The climate forecast predicts a sunny day with a excessive temperature round 30 levels Celsius, excellent for a day on the seashore with family and friends.",
  "negation": "The climate forecast predicts a wet day with a low temperature round 10 levels Celsius, not preferrred for a day on the seashore with family and friends."
}
```

import re
import json

def format_results(s):
  sample = r'```jsonn(.*?)n```'

  # Discover all occurrences of JSON objects within the string
  json_matches = re.findall(sample, s, re.DOTALL)
  if not json_matches:
    # attempt to discover 2nd sample
    sample = r'{.*?"sentence":.*?"negation":.*?}'
    json_matches = re.findall(sample, s)

  # Return the primary JSON object discovered, or None if no match is discovered
  return json.masses(json_matches[0]) if json_matches else None