Upload run_unsloth.py with huggingface_hub

run_unsloth.py

@@ -0,0 +1,366 @@
+from unsloth import FastLanguageModel
+import torch
+import json
+max_seq_length = 2048 # Choose any! We auto support RoPE Scaling internally!
+dtype = None          # None for auto detection. Float16 for Tesla T4, V100, Bfloat16 for Ampere+
+load_in_4bit = False   # Use 4bit quantization to reduce memory usage. Can be False.
+from huggingface_hub import hf_hub_download
+
+model_name = "Qwen/Qwen1.5-7B"
+cache_path = hf_hub_download(repo_id=model_name, filename="config.json")
+print(cache_path) 
+
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name = "Qwen/Qwen2.5-Coder-7B-Instruct", #"unsloth/Qwen2.5-Coder-7B-Instruct",
+    use_cache=True,
+    cache_dir = "/home/cse/msr/csy227517/.cache/huggingface/hub/models--Qwen--Qwen1.5-7B/snapshots/831096e3a59a0789a541415da25ef195ceb802fe/",
+    max_seq_length = max_seq_length,
+    dtype = dtype,
+    load_in_4bit = load_in_4bit,
+    # token = "hf_...", # use one if using gated models like meta-llama/Llama-2-7b-hf
+)
+
+
+model = FastLanguageModel.get_peft_model(
+    model,
+    r = 16, # Choose any number > 0 ! Suggested 8, 16, 32, 64, 128
+    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"] , #"gate_proj", "up_proj", "down_proj",],
+    lora_alpha = 16,
+    lora_dropout = 0,    # Supports any, but = 0 is optimized
+    bias = "none",       # Supports any, but = "none" is optimized
+    # [NEW] "unsloth" uses 30% less VRAM, fits 2x larger batch sizes!
+    use_gradient_checkpointing = "unsloth", # True or "unsloth" for very long context
+    random_state = 3407,
+    use_rslora = False,  # We support rank stabilized LoRA
+    loftq_config = None, # And LoftQ
+)
+
+
+from datasets import load_dataset, Dataset
+from unsloth.chat_templates import get_chat_template
+from unsloth.chat_templates import standardize_sharegpt
+
+tokenizer = get_chat_template(
+    tokenizer,
+    chat_template = "qwen-2.5",
+)
+
+def formatting_prompts_func(examples):
+    convos = examples["conversations"]
+    texts = [tokenizer.apply_chat_template(convo, tokenize=False, add_generation_prompt=False) for convo in convos]
+    return { "text" : texts, }
+
+#dataset = load_dataset("mlabonne/FineTome-100k", split="train")
+traindataset_file = "./dataset_lfs/CN_py800_catmix_5rand_4fold_train_pairs_0.json" #"./dataset_lfs/CN_py800_catmix_5rand_4fold_train_oripairs_sampled.json" # './dataset_lfs/CN_py800_catmix_5rand_4fold_train_full_sampled.json'
+traindata = []
+with open(traindataset_file, 'r') as file:
+    for l in file:
+        traindata.append(json.loads(l))
+        
+dataset = Dataset.from_dict({key: [d[key] for d in traindata] for key in traindata[0]})
+print(dataset.column_names)
+valdataset_file = "./llm_for_code/datasets/codecontests/CN_py800_catmix_5rand_val_pairss.json" #CN_py800_catmix_5rand_val_oripairs_sampled.json" #
+valdata = []
+with open(valdataset_file, 'r') as file:
+    for l in file:
+        valdata.append(json.loads(l))
+        
+valdataset = Dataset.from_dict({key: [d[key] for d in valdata] for key in valdata[0]})
+
+prompt = "Given two programs, check if they both solve the same problem or not i.e. for any given input, would they both give the same output or not. Give the answer as either 'Yes' or 'No'. Explanation is not required \nProgram 1:"
+def create_conversations(example, prompt = prompt):
+    if example['label']:
+        ans = "Yes"
+    else:
+        ans = "No"
+    prompt_ext = prompt + example['prog1']['scode'] + "\nProgram 2:" + example['prog2']['scode'] + '\n'
+    return {
+        "conversations": [
+            
+            #{"role": "system", "content": "You are a helpful assistant."},  # Optional system context
+            {"role": "user", "content": prompt_ext},
+            {"role": "assistant", "content": ans}
+        ]
+    }
+
+dataset = dataset.map(create_conversations)
+dataset = standardize_sharegpt(dataset)
+dataset = dataset.map(formatting_prompts_func, batched=True)
+def format_dataset(example):
+    full_text = example["text"]  # Full conversation
+
+    # Ensure assistant part is extracted
+    parts = full_text.split("<|im_start|>assistant\n")
+    
+    if len(parts) < 2:
+        return None  # Skip if there's no assistant response
+
+    input_text = parts[0]  # System + User
+    output_text = parts[1].split("<|im_end|>")[0].strip()  # Assistant response
+
+    if not output_text:
+        return None  # Skip examples with no assistant response
+
+    # Tokenize input and output separately
+    inputs = tokenizer(input_text, padding="max_length", truncation=True, max_length=512)
+    labels = tokenizer(output_text, padding="max_length", truncation=True, max_length=512)["input_ids"]
+
+    # Replace padding token ID with -100 to ignore loss computation on padding
+    labels = [(l if l != tokenizer.pad_token_id else -100) for l in labels]
+
+    # Ensure labels contain real tokens
+    if all(l == -100 for l in labels):
+        return None  # Skip bad examples
+
+    inputs["labels"] = labels
+    return inputs
+
+# Apply transformation
+dataset = dataset.map(format_dataset, batched=False, remove_columns=["text"])
+
+valdataset = valdataset.map(create_conversations)
+valdataset = standardize_sharegpt(valdataset)
+valdataset = valdataset.map(formatting_prompts_func, batched=True)
+
+
+valdataset = valdataset.map(format_dataset, batched=False)
+
+print(valdataset[0], dataset[0])
+from trl import SFTTrainer
+from transformers import TrainingArguments, DataCollatorForSeq2Seq
+from unsloth import is_bfloat16_supported
+import wandb
+from transformers import TrainingArguments, TrainerCallback
+
+wandb.init(project="qwen_training", name="HPC_19_02_25_qwen_CN_py800_per2")
+
+class SaveBestModelCallback(TrainerCallback):
+    def __init__(self, trainer):
+        self.trainer = trainer
+        self.best_val_loss = float("inf")
+
+    def on_evaluate(self, args, state, control, metrics, **kwargs):
+        val_loss = metrics.get("eval_loss")
+        if val_loss is not None and val_loss < self.best_val_loss:
+            self.best_val_loss = val_loss
+            print(f" New best model found! Saving at step {state.global_step} (Val Loss: {val_loss:.4f})")
+            self.trainer.save_model(f"{args.output_dir}/best_model")  # Save best model
+
+
+from transformers import DataCollatorForSeq2Seq
+
+class DebugDataCollator(DataCollatorForSeq2Seq):
+    def __call__(self, features):
+        batch = super().__call__(features)  # Process batch normally
+
+        # Check if "text" exists, otherwise use decoded input_ids
+        raw_text = features[0].get("text", tokenizer.decode(features[0]["input_ids"], skip_special_tokens=False))
+        input_ids = batch["input_ids"][0]  # Take first sample from batch
+        labels = batch["labels"][0] if "labels" in batch else None
+        
+        print("\n🔹 Raw Input Sentence:\n", raw_text)
+        print("\n🔹 Raw labels:\n", labels)
+        print("\n🔹 Tokenized Input IDs:\n", input_ids)
+        print("\n🔹 Decoded Input Sentence:\n", tokenizer.decode(input_ids, skip_special_tokens=False))
+
+        if labels is not None:
+            output_text = tokenizer.decode([t if t != -100 else tokenizer.pad_token_id for t in labels], skip_special_tokens=False)
+            print("\n🔹 Tokenized Output IDs:\n", labels)
+            print("\n🔹 Decoded Output Sentence:\n", output_text)
+
+        return batch
+
+
+
+trainer = SFTTrainer(
+    model = model,
+    tokenizer = tokenizer,
+    train_dataset = dataset,
+    eval_dataset = valdataset,
+    dataset_text_field = "text",
+    max_seq_length = max_seq_length,
+    data_collator = DataCollatorForSeq2Seq(tokenizer = tokenizer),
+    dataset_num_proc = 4,
+    packing = False, # Can make training 5x faster for short sequences.
+    #data_collator=DebugDataCollator(tokenizer=tokenizer),
+    args = TrainingArguments(
+        per_device_train_batch_size = 1,
+        gradient_accumulation_steps = 4, # Fixed major bug in latest Unsloth
+        warmup_steps = 5,
+        num_train_epochs = 5, # Set this for 1 full training run.
+        #max_steps = 30,
+        learning_rate = 2e-4,
+        fp16 = not is_bfloat16_supported(),
+        bf16 = is_bfloat16_supported(),
+        logging_steps = 1000,
+        evaluation_strategy="steps",  # Evaluate at set intervals
+        eval_steps=1000,  # Evaluate every 1000 steps
+        save_steps=8000,  # Save every 5000 steps
+        save_total_limit=5,
+        load_best_model_at_end=True,
+        metric_for_best_model="eval_loss",  # Use validation loss
+        greater_is_better=False, 
+        optim = "paged_adamw_8bit", # Save more memory
+        weight_decay = 0.01,
+        lr_scheduler_type = "linear",
+        seed = 3407,
+        output_dir = "HPC_19_02_25_qwen_CN_py800_catmix_5rand_perchat_4",
+        report_to = "wandb", # Use this for WandB etc
+    ),
+)
+
+
+from transformers import DataCollatorForSeq2Seq
+
+
+
+trainer.add_callback(SaveBestModelCallback(trainer))
+
+
+
+from unsloth.chat_templates import train_on_responses_only
+
+# trainer = train_on_responses_only(
+    # trainer,
+    # instruction_part = "<|im_start|>user\n",
+    # response_part = "<|im_start|>assistant\n",
+# )
+
+
+tokenizer.decode(trainer.train_dataset[5]["input_ids"])
+
+space = tokenizer(" ", add_special_tokens = False).input_ids[0]
+tokenizer.decode([space if x == -100 else x for x in trainer.train_dataset[5]["labels"]])
+
+#@title Show current memory stats
+gpu_stats = torch.cuda.get_device_properties(0)
+start_gpu_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)
+max_memory = round(gpu_stats.total_memory / 1024 / 1024 / 1024, 3)
+
+print(f"GPU = {gpu_stats.name}. Max memory = {max_memory} GB.")
+print(f"{start_gpu_memory} GB of memory reserved.")
+print(trainer.train_dataset[0].keys())
+trainer.evaluate()
+
+trainer_stats = trainer.train()
+
+wandb.finish()
+
+#@title Show final memory and time stats
+used_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)
+used_memory_for_lora = round(used_memory - start_gpu_memory, 3)
+used_percentage = round(used_memory         /max_memory*100, 3)
+lora_percentage = round(used_memory_for_lora/max_memory*100, 3)
+
+print(f"{trainer_stats.metrics['train_runtime']} seconds used for training.")
+print(f"{round(trainer_stats.metrics['train_runtime']/60, 2)} minutes used for training.")
+print(f"Peak reserved memory = {used_memory} GB.")
+print(f"Peak reserved memory for training = {used_memory_for_lora} GB.")
+print(f"Peak reserved memory % of max memory = {used_percentage} %.")
+print(f"Peak reserved memory for training % of max memory = {lora_percentage} %.")
+
+
+
+
+from unsloth.chat_templates import get_chat_template
+
+tokenizer = get_chat_template(
+    tokenizer,
+    chat_template = "qwen-2.5",
+)
+FastLanguageModel.for_inference(model) # Enable native 2x faster inference
+
+messages = [
+    {"role": "user", "content": "Continue the fibonnaci sequence: 1, 1, 2, 3, 5, 8,"},
+]
+inputs = tokenizer.apply_chat_template(
+    messages,
+    tokenize = True,
+    add_generation_prompt = True, # Must add for generation
+    return_tensors = "pt",
+).to("cuda")
+
+outputs = model.generate(input_ids = inputs, max_new_tokens = 64, use_cache = True,
+                         temperature = 1.5, min_p = 0.1)
+tokenizer.batch_decode(outputs)
+
+
+
+FastLanguageModel.for_inference(model) # Enable native 2x faster inference
+
+# messages = [
+    # {"role": "user", "content": "Continue the fibonnaci sequence: 1, 1, 2, 3, 5, 8,"},
+# ]
+# inputs = tokenizer.apply_chat_template(
+    # messages,
+    # tokenize = True,
+    # add_generation_prompt = True, # Must add for generation
+    # return_tensors = "pt",
+# ).to("cuda")
+
+# from transformers import TextStreamer
+# text_streamer = TextStreamer(tokenizer, skip_prompt = True)
+# _ = model.generate(input_ids = inputs, streamer = text_streamer, max_new_tokens = 128, \
+                   # use_cache = True, temperature = 1.5, min_p = 0.1)
+                   
+                   
+                   
+model.save_pretrained("HPC_19_02_25_qwen_CN_py800_catmix_5rand_perchat_4/unslothlora_model") # Local saving
+tokenizer.save_pretrained("HPC_19_02_25_qwen_CN_py800_catmix_5rand_perchat_4/unslothlora_model")
+
+# model.push_to_hub("your_name/lora_model", token = "...") # Online saving
+# tokenizer.push_to_hub("your_name/lora_model", token = "...") # Online saving
+
+from unsloth import FastLanguageModel
+from transformers import TextStreamer
+
+if False:
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name="unslothlora_model", # YOUR MODEL YOU USED FOR TRAINING
+        max_seq_length=max_seq_length,
+        dtype=dtype,
+        load_in_4bit=load_in_4bit,
+    )
+
+FastLanguageModel.for_inference(model)
+
+messages = [
+    {"role": "user", "content": prompt + "print(hi) \nProgram 2: print(\"hi\")\n"},
+]
+inputs = tokenizer.apply_chat_template(
+    messages,
+    tokenize=True,
+    add_generation_prompt=True, # Must add for generation
+    return_tensors="pt",
+).to("cuda")
+
+text_streamer = TextStreamer(tokenizer, skip_prompt = True)
+_ = model.generate(input_ids=inputs, streamer=text_streamer, max_new_tokens=128, use_cache=True, temperature=1.5, min_p=0.1)
+
+
+
+
+# from unsloth import FastLanguageModel
+# from transformers import TextStreamer
+
+# if False:    
+    # new_model, new_tokenizer = FastLanguageModel.from_pretrained(
+        # model_name="lora_model", # YOUR MODEL YOU USED FOR TRAINING
+        # max_seq_length=max_seq_length,
+        # dtype=dtype,
+        # load_in_4bit=load_in_4bit,
+    # )
+    # FastLanguageModel.for_inference(new_model) # Enable native 2x faster inference
+    
+    # messages = [
+        # {"role": "user", "content": "Describe a famous statue in New York City."},
+    # ]
+    # inputs = new_tokenizer.apply_chat_template(
+        # messages,
+        # tokenize=True,
+        # add_generation_prompt=True, # Must add for generation
+        # return_tensors="pt",
+    # ).to("cuda")
+    
+    # text_streamer = TextStreamer(new_tokenizer, skip_prompt = True)
+    # _ = new_model.generate(input_ids=inputs, streamer=text_streamer, max_new_tokens=128, use_cache=True, temperature=1.5, min_p=0.1)